Добавьте файлы проекта.

ArgumentsToolkit.Validation/ArgumentsToolkit.Validation.csproj

@@ -0,0 +1,25 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+	<PropertyGroup>
+		<TargetFramework>net8.0</TargetFramework>
+		<PackageId>ArgumentsToolkit.Validation</PackageId>
+		<Version>1.0.0</Version>
+		<Authors>FrigaT</Authors>
+		<Company>FrigaT</Company>
+		<Description>Расширение для ArgumentsToolkit.Core: атрибуты и правила валидации аргументов.</Description>
+		<PackageTags>cli arguments parser validation toolkit</PackageTags>
+		<RepositoryUrl>https://git.frigat.duckdns.org/FrigaT/ArgumentsToolkit</RepositoryUrl>
+		<PackageLicenseExpression>MIT</PackageLicenseExpression>
+
+		<GeneratePackageOnBuild>true</GeneratePackageOnBuild>
+		<GenerateDocumentationFile>true</GenerateDocumentationFile>
+		<Nullable>enable</Nullable>
+		<ImplicitUsings>enable</ImplicitUsings>
+		<LangVersion>latest</LangVersion>
+	</PropertyGroup>
+
+	<ItemGroup>
+		<ProjectReference Include="..\ArgumentsToolkit.Core\ArgumentsToolkit.Core.csproj" />
+	</ItemGroup>
+
+</Project>

ArgumentsToolkit.Validation/ValidationException.cs

@@ -0,0 +1,13 @@
+namespace ArgumentsToolkit;
+
+/// <summary>
+/// Исключение, выбрасываемое при нарушении правил валидации аргументов.
+/// </summary>
+public class ValidationException : Exception
+{
+    /// <summary>
+    /// Создаёт новое исключение валидации.
+    /// </summary>
+    /// <param name="message">Сообщение об ошибке.</param>
+    public ValidationException(string message) : base(message) { }
+}

ArgumentsToolkit.Validation/Validations/AllowedValuesAttribute.cs

@@ -0,0 +1,53 @@
+namespace ArgumentsToolkit;
+
+/// <summary>
+/// Атрибут для проверки строкового значения на соответствие списку допустимых значений.
+/// </summary>
+[AttributeUsage(AttributeTargets.Property)]
+public class AllowedValuesAttribute : ValidationAttribute
+{
+    /// <summary>
+    /// Список допустимых значений.
+    /// </summary>
+    public string[] Values { get; }
+
+    /// <summary>
+    /// Создаёт новый атрибут допустимых значений.
+    /// </summary>
+    /// <param name="values">Массив допустимых строковых значений.</param>
+    public AllowedValuesAttribute(params string[] values)
+    {
+        Values = values;
+    }
+
+    /// <summary>
+    /// Создаёт новый атрибут допустимых значений.
+    /// </summary>
+    /// <param name="en">Enum допустимых значений.</param>
+    public AllowedValuesAttribute(Enum en)
+    {
+        var enums = Enum.GetValues(en.GetType());
+        List<string> values = new();
+
+        foreach (var e in enums)
+        {
+            values.Add(e.ToString());
+        }
+
+        Values = values.ToArray();
+    }
+
+    public override string ErrorTemplate { get; set; } = "--{0}: значение {1} не входит в диапазон [{2}]";
+
+    public override bool Validate(object? value)
+    {
+        if (value is string s)
+            return Values.Contains(s);
+        return true;
+    }
+
+    public override string GetErrorMessage(string optionName, object? value)
+    {
+        return string.Format(ErrorTemplate, optionName, value, string.Join(", ", Values));
+    }
+}

ArgumentsToolkit.Validation/Validations/RangeAttribute.cs

@@ -0,0 +1,48 @@
+namespace ArgumentsToolkit;
+
+/// <summary>
+/// Атрибут для проверки числового значения на соответствие диапазону.
+/// Применяется к свойствам модели Options.
+/// </summary>
+[AttributeUsage(AttributeTargets.Property)]
+public partial class RangeAttribute : ValidationAttribute
+{
+    /// <summary>
+    /// Минимально допустимое значение.
+    /// </summary>
+    public double Min { get; }
+
+    /// <summary>
+    /// Максимально допустимое значение.
+    /// </summary>
+    public double Max { get; }
+
+    /// <summary>
+    /// Создаёт новый атрибут диапазона.
+    /// </summary>
+    /// <param name="min">Минимальное значение.</param>
+    /// <param name="max">Максимальное значение.</param>
+    public RangeAttribute(double min, double max)
+    {
+        Min = min;
+        Max = max;
+    }
+
+    public override string ErrorTemplate { get; set; } = "--{0}: значение {1} выходит за диапазон {2}..{3}";
+
+    public override bool Validate(object? value)
+    {
+        if (value is IConvertible c)
+        {
+            var d = c.ToDouble(System.Globalization.CultureInfo.InvariantCulture);
+            if (d < Min || d > Max)
+                return false;
+        }
+        return true;
+    }
+
+    public override string GetErrorMessage(string optionName, object? value)
+    {
+        return string.Format(ErrorTemplate, optionName, value, Min, Max);
+    }
+}

ArgumentsToolkit.Validation/Validations/RegexAttribute.cs

@@ -0,0 +1,43 @@
+using System.Text.RegularExpressions;
+
+namespace ArgumentsToolkit;
+
+public partial class RangeAttribute
+{
+    /// <summary>
+    /// Атрибут для проверки строкового значения по регулярному выражению.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Property)]
+    public class RegexAttribute : ValidationAttribute
+    {
+        /// <summary>
+        /// Шаблон регулярного выражения.
+        /// </summary>
+        public string Pattern { get; }
+
+        /// <summary>
+        /// Создаёт новый атрибут регулярного выражения.
+        /// </summary>
+        /// <param name="pattern">Регулярное выражение для проверки.</param>
+        public RegexAttribute(string pattern)
+        {
+            Pattern = pattern;
+        }
+
+        public override string ErrorTemplate { get; set; } = "--{0}: значение {1} не соответствует регулярному выражению '{2}'";
+
+        public override bool Validate(object? value)
+        {
+            if (value is string s)
+                return Regex.IsMatch(s, Pattern);
+            return true;
+
+        }
+
+        public override string GetErrorMessage(string optionName, object? value)
+        {
+            return string.Format(ErrorTemplate, optionName, value, Pattern);
+        }
+    }
+
+}

ArgumentsToolkit.Validation/Validations/ValidationAttribute.cs

@@ -0,0 +1,23 @@
+namespace ArgumentsToolkit;
+
+/// <summary>
+/// Базовый атрибут для всех правил валидации.
+/// </summary>
+[AttributeUsage(AttributeTargets.Property, AllowMultiple = true)]
+public abstract class ValidationAttribute : Attribute
+{
+    /// <summary>Кастомное сообщение об ошибке.</summary>
+    public abstract string ErrorTemplate { get; set; }
+
+    /// <summary>
+    /// Проверяет значение свойства.
+    /// </summary>
+    /// <param name="value">Значение свойства.</param>
+    public abstract bool Validate(object? value);
+
+    /// <summary>
+    /// Возвращает сообщение об ошибке для указанного значения.
+    /// </summary>
+    public abstract string GetErrorMessage(string optionName, object? value);
+
+}

ArgumentsToolkit.Validation/Validator.cs

@@ -0,0 +1,45 @@
+using System.Reflection;
+
+namespace ArgumentsToolkit;
+
+/// <summary>
+/// Класс для выполнения валидации модели Options на основе атрибутов.
+/// </summary>
+public static class Validator
+{
+    /// <summary>
+    /// Проверяет объект <paramref name="options"/> на соответствие правилам валидации.
+    /// </summary>
+    /// <typeparam name="T">Тип модели опций.</typeparam>
+    /// <param name="options">Экземпляр модели опций.</param>
+    /// <param name="errors">Список ошибок валидации.</param>
+    /// <returns>true, если ошибок нет; иначе false.</returns>
+    public static bool Validate<T>(T options, out string[] errors)
+    {
+        var list = new List<string>();
+        var props = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance);
+
+        foreach (var p in props)
+        {
+            // Проверяем только свойства с [Option]
+            var optionAttr = p.GetCustomAttribute<OptionAttribute>();
+            if (optionAttr == null) continue;
+
+            var val = p.GetValue(options);
+
+            // Берём все атрибуты, которые реализуют IValidationAttribute
+            foreach (var attr in p.GetCustomAttributes().OfType<ValidationAttribute>())
+            {
+                if (!attr.Validate(val))
+                {
+                    var error = attr.GetErrorMessage(optionAttr.Name, val);
+                    list.Add(error);
+                }
+            }
+        }
+
+        errors = list.ToArray();
+        return list.Count == 0;
+    }
+
+}