diff --git a/Simple.ArgumentParser.Example/Program.cs b/Simple.ArgumentParser.Example/Program.cs
index eb4bb20..63acfec 100644
--- a/Simple.ArgumentParser.Example/Program.cs
+++ b/Simple.ArgumentParser.Example/Program.cs
@@ -1,74 +1,67 @@
 using Simple.ArgumentParser;
-using Type = Simple.ArgumentParser.Type;
 
-args = ["--key", "just", "a", "key", "--bool", "true", "--number", "42"];
+//args = ["-t", "hejsan", "-n", "3.1", "-b", "true", "-f", "-fl", "1.3" ];
 
-var arguments = new Parser()
-    .Options
-    .Add(name: "key",
-        shortName: "k",
-        description: "An alphanumeric value",
-        type: Type.Alpha,
-        required: true)
-    .Add(name: "flag",
-        shortName: "f",
-        description: "Just a simple flag",
-        type: Type.None,
+var arguments = new ArgumentParser()
+    .AddAlphaOption(name: "name",
+        shortName: 'n',
+        description: "Your full name",
         required: false)
-    .Add(name: "bool",
-        shortName: "b",
-        description: "A boolean value (true/false)",
-        type: Type.Boolean,
-        required: true)
-    .Add(name: "a-super-long-option",
-        shortName: "l",
-        description: "This is a really long option",
-        type: Type.Alpha,
+    .AddIntegerOption(name: "age",
+        shortName: 'a',
+        description: "Your age",
         required: false)
-    .Add(name: "number",
-        shortName: "n",
-        description: "An integer value",
-        type: Type.Integer,
-        required: true)
-    .AddHelp()
-    .AddVersion()
-    .AddDescription("A description of the application.")
-    .Build()
+    .AddEnumerateOption(name: "sex",
+        shortName: 's',
+        description: "Enter your sex (male/female/idiot)",
+        ["male", "female", "idiot"],
+        required: false)
+    .AddBooleanOption(name: "happy",
+        shortName: 'H',
+        description: "If you are happy or not",
+        required: false)
+    .AddHelpOption("A description of the application.")
+    .AddVersionOption("1.2.3-alpha")
     .Parse(args);
 
-
 // handle help command
-if (arguments.ShowHelpRequested)
+if (arguments.HelpRequested)
 {
     Console.WriteLine(arguments.HelpSection);
     return 1;
 }
 
 // handle version command
-if (arguments.ShowVersionRequested)
+if (arguments.VersionRequested)
 {
     Console.WriteLine(arguments.Version);
     return 2;
 }
 
 // handle invalid commands
-if (arguments.InvalidCommands.Count > 0)
+if (arguments.HasInvalidCommands)
 {
-    arguments.InvalidCommands.ForEach(Console.WriteLine);
-    return -2;
+    arguments.Invalid.ForEach(Console.WriteLine);
 }
 
 // handle missing commands
-if (arguments.MissingCommands.Count > 0)
+if (arguments.HasMissingCommands)
+{
+    arguments.Missing.ForEach(Console.WriteLine);
+}
+
+// handle ignored commands
+if (arguments.HasIgnoredCommands)
 {
-    arguments.MissingCommands.ForEach(c => Console.WriteLine($"Required command is missing: {c}"));
-    return -1;
+    Console.WriteLine("Ignored commands:");
+    arguments.Ignored.ForEach(c => Console.WriteLine($"Name: {c.Name}, Type: {c.OptionType}, Value: {c.Value}"));
 }
 
-arguments.ValidCommands.ForEach(c => Console.WriteLine($"Name: {c.Name}, Type: {c.Type}, Value: {c.Value}"));
+// handle valid commands
+if (arguments.IsValid && arguments.Any())
+{
+    Console.WriteLine("Valid commands:");
+    arguments.GetAll().ForEach(c => Console.WriteLine($"Name: {c.Name}, Type: {c.OptionType}, Value: {c.Value}"));
+}
 
-Console.WriteLine($"Hello, {arguments.ValidCommands.Single(c => c.Name == "name").Value}! You look " +
-                  $"a lot older than {arguments.ValidCommands.Single(c => c.Name == "age").Value}. " +
-                  $"Also, you are {(arguments.ValidCommands.Single(c => c.Name == "is-cool").Value == "true" ? "very" : "not very")} cool.");
-Console.WriteLine($"Flag: {arguments.ValidCommands.Any(c => c.Name == "just-a-flag")}");
 return 0;
\ No newline at end of file
diff --git a/Simple.ArgumentParser.Tests/ArgumentParserTests.cs b/Simple.ArgumentParser.Tests/ArgumentParserTests.cs
new file mode 100644
index 0000000..8649022
--- /dev/null
+++ b/Simple.ArgumentParser.Tests/ArgumentParserTests.cs
@@ -0,0 +1,79 @@
+namespace Simple.ArgumentParser.Tests;
+
+public class ArgumentParserTests
+{
+    [Fact]
+    public void Parse_should_handle_expected_arguments()
+    {
+        // arrange
+
+        string[] args = [ 
+            "--alpha", "value",
+            "--boolean", "true",
+            "--char", "c",
+            "--double", "3.14",
+            "--enumerate", "a",
+            "--flag",
+            "--integer", "42",
+            "--help",
+            "--version"
+        ];
+        
+        var subjectUnderTest = new ArgumentParser()
+            .AddAlphaOption("alpha", 'a', "description")
+            .AddBooleanOption("boolean", 'b', "description")
+            .AddCharOption("char", 'c', "description")
+            .AddDoubleOption("double", 'd', "description")
+            .AddEnumerateOption("enumerate", 'e', "description", ["a", "b", "c"])
+            .AddFlagOption("flag", 'f', "description")
+            .AddIntegerOption("integer", 'i', "description")
+            .AddVersionOption()
+            .AddHelpOption();
+
+        // act
+
+        var result = subjectUnderTest.Parse(args);
+
+        // assert
+
+        Assert.NotNull(result);
+        Assert.True(result.HelpRequested);
+        Assert.True(result.VersionRequested);
+        Assert.True(result.IsValid);
+        Assert.False(result.HasMissingCommands);
+        Assert.False(result.HasIgnoredCommands);
+        Assert.False(result.HasInvalidCommands);
+        Assert.NotNull(result.Version);
+        Assert.NotEmpty(result.Version);
+        Assert.NotNull(result.HelpSection);
+        Assert.NotEmpty(result.HelpSection);
+        Assert.NotNull(result.Get("alpha"));
+    }
+
+    [Fact]
+    public void Parse_should_ignore_unexpected_arguments()
+    {
+        // arrange
+
+        var args = new[] { "--help" };
+        
+        var subjectUnderTest = new ArgumentParser();
+        
+        // act
+
+        var result = subjectUnderTest.Parse(args);
+        
+        // assert
+        
+        Assert.NotNull(result);
+        Assert.False(result.HelpRequested);
+        Assert.False(result.VersionRequested);
+        Assert.True(result.IsValid);
+        Assert.False(result.HasMissingCommands);
+        Assert.True(result.HasIgnoredCommands);
+        Assert.False(result.HasInvalidCommands);
+        Assert.Null(result.Version);
+        Assert.Null(result.HelpSection);
+        Assert.Null(result.Get("help"));
+    }
+}
\ No newline at end of file
diff --git a/Simple.ArgumentParser.Tests/Options/AlphaOptionTests.cs b/Simple.ArgumentParser.Tests/Options/AlphaOptionTests.cs
new file mode 100644
index 0000000..a697a35
--- /dev/null
+++ b/Simple.ArgumentParser.Tests/Options/AlphaOptionTests.cs
@@ -0,0 +1,33 @@
+using Simple.ArgumentParser.Options;
+
+namespace Simple.ArgumentParser.Tests.Options;
+
+public class AlphaOptionTests
+{
+    private static AlphaOption GetSubjectUnderTest(OptionSettings? settings = null) => new (
+        name: "test-name",
+        shortName: 't',
+        description: "test-description",
+        settings: settings ?? new OptionSettings());
+
+    [Theory]
+    [InlineData("alpha")]
+    [InlineData("123")]
+    [InlineData("true")]
+    [InlineData(" ")]
+    public void ValueIsValid_should_return_true(string inlineData)
+    {
+        // arrange
+
+        var subjectUnderTest = GetSubjectUnderTest();
+
+        // act
+
+        var result = subjectUnderTest.ValueIsValid(inlineData, out var message);
+
+        // assert
+
+        Assert.True(result);
+        Assert.Empty(message);
+    }
+}
\ No newline at end of file
diff --git a/Simple.ArgumentParser.Tests/Options/BooleanOptionTests.cs b/Simple.ArgumentParser.Tests/Options/BooleanOptionTests.cs
new file mode 100644
index 0000000..bed1863
--- /dev/null
+++ b/Simple.ArgumentParser.Tests/Options/BooleanOptionTests.cs
@@ -0,0 +1,78 @@
+using Simple.ArgumentParser.Options;
+
+namespace Simple.ArgumentParser.Tests.Options;
+
+public class BooleanOptionTests
+{
+    private static BooleanOption GetSubjectUnderTest(OptionSettings? settings = null) => new(
+        name: "test-name",
+        shortName: 't',
+        description: "test-description",
+        settings: settings ?? new OptionSettings());
+
+    private static OptionSettings GetStrictSettings() => new OptionSettings
+    {
+        Strict = true,
+        Required = false
+    };
+
+    [Theory]
+    [InlineData("true")]
+    [InlineData("false")]
+    [InlineData("1")]
+    [InlineData("0")]
+    public void ValueIsValid_should_return_true_with_strict_off(string inlineData)
+    {
+        // arrange
+
+        var subjectUnderTest = GetSubjectUnderTest();
+
+        // act
+
+        var result = subjectUnderTest.ValueIsValid(inlineData, out var message);
+
+        // assert
+
+        Assert.True(result);
+        Assert.Empty(message);
+    }
+
+    [Theory]
+    [InlineData("1")]
+    [InlineData("0")]
+    public void ValueIsValid_should_return_false_with_strict_on(string inlineData)
+    {
+        // arrange
+
+        var subjectUnderTest = GetSubjectUnderTest(GetStrictSettings());
+
+        // act
+
+        var result = subjectUnderTest.ValueIsValid(inlineData, out var message);
+
+        // assert
+
+        Assert.False(result);
+        Assert.NotEmpty(message);
+    }
+    
+    [Theory]
+    [InlineData("-1")]
+    [InlineData("-0")]
+    [InlineData("text")]
+    public void ValueIsValid_should_return_false_with_strict_off(string inlineData)
+    {
+        // arrange
+
+        var subjectUnderTest = GetSubjectUnderTest();
+
+        // act
+
+        var result = subjectUnderTest.ValueIsValid(inlineData, out var message);
+
+        // assert
+
+        Assert.False(result);
+        Assert.NotEmpty(message);
+    }
+}
\ No newline at end of file
diff --git a/Simple.ArgumentParser.Tests/Simple.ArgumentParser.Tests.csproj b/Simple.ArgumentParser.Tests/Simple.ArgumentParser.Tests.csproj
index 085bddd..906c421 100644
--- a/Simple.ArgumentParser.Tests/Simple.ArgumentParser.Tests.csproj
+++ b/Simple.ArgumentParser.Tests/Simple.ArgumentParser.Tests.csproj
@@ -20,4 +20,8 @@
         <Using Include="Xunit"/>
     </ItemGroup>
 
+    <ItemGroup>
+      <ProjectReference Include="..\Simple.ArgumentParser\Simple.ArgumentParser.csproj" />
+    </ItemGroup>
+
 </Project>
diff --git a/Simple.ArgumentParser.Tests/UnitTest1.cs b/Simple.ArgumentParser.Tests/UnitTest1.cs
deleted file mode 100644
index 14f084d..0000000
--- a/Simple.ArgumentParser.Tests/UnitTest1.cs
+++ /dev/null
@@ -1,9 +0,0 @@
-namespace Simple.ArgumentParser.Tests;
-
-public class UnitTest1
-{
-    [Fact]
-    public void Test1()
-    {
-    }
-}
\ No newline at end of file
diff --git a/Simple.ArgumentParser/Args.cs b/Simple.ArgumentParser/Args.cs
new file mode 100644
index 0000000..f875945
--- /dev/null
+++ b/Simple.ArgumentParser/Args.cs
@@ -0,0 +1,34 @@
+namespace Simple.ArgumentParser;
+
+public class Args
+{
+    public bool IsValid => !(HasInvalidCommands || HasMissingCommands);
+    public bool HasIgnoredCommands => Ignored.Count > 0;
+    public bool HasMissingCommands => Missing.Count > 0;
+    public bool HasInvalidCommands => Invalid.Count > 0;
+    public bool HelpRequested { get; internal set; }
+    public bool VersionRequested { get; internal set; }
+
+
+    public List<Command> Valid { get; set; } = [];
+    public List<Command> Ignored { get; } = [];
+    public List<string> Missing { get; } = [];
+    public List<string> Invalid { get; } = [];
+    public string? HelpSection { get; internal set; }
+    public string? Version { get; internal set; }
+
+
+    internal Args()
+    {
+    }
+
+    
+    public bool Any() => Valid.Count > 0;
+
+    public Command? Get(string key)
+    {
+        return Valid.SingleOrDefault(c => c.Name == key);
+    }
+
+    public List<Command> GetAll() => Valid;
+}
\ No newline at end of file
diff --git a/Simple.ArgumentParser/ArgumentOptionException.cs b/Simple.ArgumentParser/ArgumentOptionException.cs
new file mode 100644
index 0000000..efb6500
--- /dev/null
+++ b/Simple.ArgumentParser/ArgumentOptionException.cs
@@ -0,0 +1,8 @@
+namespace Simple.ArgumentParser;
+
+public class ArgumentOptionException : Exception
+{
+    public ArgumentOptionException(string message) : base(message)
+    {
+    }
+}
\ No newline at end of file
diff --git a/Simple.ArgumentParser/ArgumentParser.cs b/Simple.ArgumentParser/ArgumentParser.cs
new file mode 100644
index 0000000..5411adc
--- /dev/null
+++ b/Simple.ArgumentParser/ArgumentParser.cs
@@ -0,0 +1,211 @@
+using System.Reflection;
+using System.Text.RegularExpressions;
+using Simple.ArgumentParser.Builders;
+using Simple.ArgumentParser.Options;
+
+namespace Simple.ArgumentParser;
+
+public class ArgumentParser
+{
+    private readonly bool _strictMode;
+    private readonly List<Option> _options = [];
+
+    private List<string> _missingCommands = [];
+    private readonly List<string> _invalidCommands = [];
+    private readonly List<Command> _ignoredCommands = [];
+    private readonly List<Command> _validCommands = [];
+
+    private string? _description;
+    private string? _version;
+
+
+    public ArgumentParser(bool strict = false)
+    {
+        _strictMode = strict;
+    }
+
+    public ArgumentParser AddVersionOption(string? version = null)
+    {
+        _version ??= version ?? Assembly.GetEntryAssembly()?.GetName().Version?.ToString() ?? "1.0.0";
+        TryAddOption(new VersionOption());
+        return this;
+    }
+
+    public ArgumentParser AddHelpOption(string? description = null)
+    {
+        _description = description;
+        TryAddOption(new HelpOption());
+        return this;
+    }
+
+    public ArgumentParser AddAlphaOption(string name, char shortName, string description, bool required = false)
+    {
+        TryAddOption(new AlphaOption(name, shortName, description, new OptionSettings { Required = required, Strict = _strictMode }));
+        return this;
+    }
+
+    public ArgumentParser AddBooleanOption(string name, char shortName, string description, bool required = false)
+    {
+        TryAddOption(new BooleanOption(name, shortName, description, new OptionSettings { Required = required, Strict = _strictMode }));
+        return this;
+    }
+
+    public ArgumentParser AddFlagOption(string name, char shortName, string description, bool required = false)
+    {
+        TryAddOption(new FlagOption(name, shortName, description, new OptionSettings { Required = required, Strict = _strictMode }));
+        return this;
+    }
+
+    public ArgumentParser AddDoubleOption(string name, char shortName, string description, bool required = false)
+    {
+        TryAddOption(new DoubleOption(name, shortName, description, new OptionSettings { Required = required, Strict = _strictMode }));
+        return this;
+    }
+
+    public ArgumentParser AddCharOption(string name, char shortName, string description, bool required = false)
+    {
+        TryAddOption(new CharOption(name, shortName, description, new OptionSettings { Required = required, Strict = _strictMode }));
+        return this;
+    }
+    
+    public ArgumentParser AddIntegerOption(string name, char shortName, string description, bool required = false)
+    {
+        TryAddOption(new IntegerOption(name, shortName, description, new OptionSettings { Required = required, Strict = _strictMode }));
+        return this;
+    }
+    
+    public ArgumentParser AddEnumerateOption(string name, char shortName, string description, string[] accepted, bool required = false)
+    {
+        TryAddOption(new EnumerateOption(name, shortName, description, accepted, new OptionSettings { Required = required, Strict = _strictMode }));
+        return this;
+    }
+
+    public Args Parse(string[] args)
+    {
+        // if (_options.Count == 0) return new Args();
+
+        foreach (Match match in Regex.Matches(string.Join(" ", args), Constants.Pattern))
+        {
+            var kv = GetKeyValue(match);
+
+            var matchingOption = GetMatchingOption(kv.Key);
+            if (matchingOption is null)
+            {
+                _ignoredCommands.Add(new Command
+                {
+                    Name = kv.Key.TrimStart(Constants.ShortPrefix.ToCharArray()),
+                    Value = kv.Value,
+                    OptionType = OptionType.Alpha,
+                });
+
+                continue;
+            }
+
+            if (!matchingOption.ValueIsValid(kv.Value, out var errorMessage))
+            {
+                _invalidCommands.Add(errorMessage);
+                continue;
+            }
+
+            _validCommands.Add(new Command
+            {
+                Value = kv.Value,
+                OptionType = matchingOption.Type,
+                Name = matchingOption.Name.TrimStart(Constants.ShortPrefix.ToCharArray())
+            });
+        }
+
+        var parsedArguments = new Args();
+        _missingCommands = GetRequiredOptionsMissing();
+        RemoveInvalidCommandsFromMissingCommands();
+
+        if (_ignoredCommands.Count > 0)
+        {
+            parsedArguments.Ignored.AddRange(_ignoredCommands);
+        }
+
+        if (_missingCommands.Count > 0)
+        {
+            parsedArguments.Missing.AddRange(_missingCommands);
+        }
+
+        if (_invalidCommands.Count > 0)
+        {
+            parsedArguments.Invalid.AddRange(_invalidCommands);
+        }
+
+        if (_validCommands.Any(a => a.Name == Constants.HelpOptionName))
+        {
+            parsedArguments.HelpRequested = true;
+            parsedArguments.HelpSection = HelpSectionBuilder.Build(_description, _options);
+        }
+
+        if (_validCommands.Any(a => a.Name == Constants.VersionOptionName))
+        {
+            parsedArguments.VersionRequested = true;
+            parsedArguments.Version = _version;
+        }
+
+        if (_validCommands.Count > 0)
+        {
+            parsedArguments.Valid = _validCommands;
+        }
+
+        return parsedArguments;
+    }
+
+
+    private void RemoveInvalidCommandsFromMissingCommands()
+    {
+        foreach (var invalidCommand in _invalidCommands)
+        {
+            var match = Regex.Match(invalidCommand, "'--\\w+'");
+            if (match.Success)
+            {
+                _missingCommands.RemoveAll(m => m.Contains(match.Value));
+            }
+        }
+    }
+
+    private static KeyValuePair<string, string> GetKeyValue(Match match)
+    {
+        var key = match.Groups["key"].Value;
+        var value = match.Groups["value"].Success
+            ? match.Groups["value"].Value.Trim()
+            : string.Empty;
+
+        return new KeyValuePair<string, string>(key, value);
+    }
+
+    private Option? GetMatchingOption(string key)
+    {
+        return key.StartsWith(Constants.LongPrefix)
+            ? _options.SingleOrDefault(o => o.Name.Equals(key, StringComparison.CurrentCultureIgnoreCase))
+            : _options.SingleOrDefault(o => o.ShortName.Equals(key, StringComparison.CurrentCultureIgnoreCase));
+    }
+
+    private List<string> GetRequiredOptionsMissing()
+    {
+        return _options
+            .Where(o => o.Settings.Required)
+            .Select(o => o.Name)
+            .Except(_validCommands.Select(a => Constants.LongPrefix + a.Name))
+            .Select(a => $"Required argument '{a}' is missing")
+            .ToList();
+    }
+
+    private void TryAddOption(Option option)
+    {
+        if (_options.Any(o => o.Name == option.Name))
+        {
+            throw new ArgumentOptionException($"Option with name '{option.Name}' already exists");
+        }
+        
+        if (_options.Any(o => o.ShortName == option.ShortName))
+        {
+            throw new ArgumentOptionException($"Option with short name '{option.ShortName}' already exists");
+        }
+        
+        _options.Add(option);
+    }
+}
\ No newline at end of file
diff --git a/Simple.ArgumentParser/Arguments.cs b/Simple.ArgumentParser/Arguments.cs
deleted file mode 100644
index a438cbd..0000000
--- a/Simple.ArgumentParser/Arguments.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-namespace Simple.ArgumentParser;
-
-public class Arguments
-{
-    public bool IsValid => InvalidCommands.Count == 0 && MissingCommands.Count == 0;
-
-    public List<Command> ValidCommands { get; set; } = [];
-    public List<string> InvalidCommands { get; set; } = [];
-    public List<string> MissingCommands { get; set; } = [];
-    public bool ShowHelpRequested { get; set; }
-    public bool ShowVersionRequested { get; set; }
-    public string HelpSection { get; }
-    public string Version { get; }
-
-    internal Arguments(Func<string> helpSection, string version)
-    {
-        HelpSection = helpSection();
-        Version = version;
-    }
-}
\ No newline at end of file
diff --git a/Simple.ArgumentParser/Builders/HelpSectionBuilder.cs b/Simple.ArgumentParser/Builders/HelpSectionBuilder.cs
new file mode 100644
index 0000000..d981542
--- /dev/null
+++ b/Simple.ArgumentParser/Builders/HelpSectionBuilder.cs
@@ -0,0 +1,40 @@
+using System.Diagnostics;
+using System.Text;
+using Simple.ArgumentParser.Options;
+
+namespace Simple.ArgumentParser.Builders;
+
+internal class HelpSectionBuilder
+{
+    internal static string Build(string? description, List<Option> options)
+    {
+        var tab = new string(' ', Constants.HelpSectionTabLength);
+        var executable = Path.GetFileName(Process.GetCurrentProcess().MainModule?.FileName);
+
+        var stringBuilder = new StringBuilder();
+        stringBuilder.AppendLine("Description:");
+        stringBuilder.AppendLine($"{tab}{description ?? ".NET Application"}");
+        stringBuilder.AppendLine();
+        stringBuilder.AppendLine("Usage:");
+        stringBuilder.AppendLine($"{tab}{executable ?? "<executable>"} [OPTIONS]");
+        stringBuilder.AppendLine();
+        stringBuilder.AppendLine("Options:");
+
+        var longestArgument = options.Max(o => o.Name.Length);
+        var longestTypeName = options.Max(o => o.Type.ToString().Length);
+        var anyRequired = options.Any(o => o.Settings.Required);
+        
+        foreach (var option in options)
+        {
+            var key = $"{tab}{option.Name.PadRight(longestArgument + 2, ' ')}{(option.ShortName != null ? $"{option.ShortName.PadRight(3, ' ')}" : string.Empty)}";
+            var type = $"{(option.Type != OptionType.Flag ? $"<{option.Type}>".PadRight(longestTypeName + 4) : "".PadRight(longestTypeName + 4))}";
+
+            stringBuilder.Append($"{key} {type}".PadRight(40, ' '));
+            stringBuilder.Append($"{(option.Settings.Required ? "(required)" : "").PadRight(12, ' ')}");
+            stringBuilder.Append(option.Description);
+            stringBuilder.AppendLine();
+        }
+
+        return stringBuilder.ToString();
+    }
+}
\ No newline at end of file
diff --git a/Simple.ArgumentParser/Builders/OptionBuilder.cs b/Simple.ArgumentParser/Builders/OptionBuilder.cs
deleted file mode 100644
index d3fb2f8..0000000
--- a/Simple.ArgumentParser/Builders/OptionBuilder.cs
+++ /dev/null
@@ -1,46 +0,0 @@
-using System.Reflection;
-
-namespace Simple.ArgumentParser.Builders;
-
-public class OptionsBuilder
-{
-    private readonly Parser _parser;
-    internal readonly List<Option> options = [];
-    internal string? description = ".NET Console Application";
-    internal string? version;
-
-    internal OptionsBuilder(Parser parser)
-    {
-        _parser = parser;
-    }
-
-    public OptionsBuilder AddDescription(string description)
-    {
-        this.description = description;
-        return this;
-    }
-
-    public OptionsBuilder AddVersion(string? version = null)
-    {
-        this.version = version ?? Assembly.GetEntryAssembly()?.GetName().Version?.ToString() ?? "1.0.0";
-        var option = new Option { Name = "--version", ShortName = "-v", Description = "Show version information", Type = Type.None, Required = false, };
-        options.Add(option);
-        return this;
-    }
-
-    public OptionsBuilder Add(string name, string shortName, string description, Type type = Type.Alpha, bool required = false)
-    {
-        var option = new Option { Name = "--" + name, ShortName = "-" + shortName, Description = description, Type = type, Required = required, };
-        options.Add(option);
-        return this;
-    }
-
-    public OptionsBuilder AddHelp()
-    {
-        var option = new Option { Name = "--help", ShortName = "-h", Description = "Show help section", Type = Type.None, Required = false, };
-        options.Add(option);
-        return this;
-    }
-
-    public Parser Build() => _parser;
-}
\ No newline at end of file
diff --git a/Simple.ArgumentParser/Command.cs b/Simple.ArgumentParser/Command.cs
index 529f46f..0b89dec 100644
--- a/Simple.ArgumentParser/Command.cs
+++ b/Simple.ArgumentParser/Command.cs
@@ -1,10 +1,12 @@
+using Simple.ArgumentParser.Options;
+
 namespace Simple.ArgumentParser;
 
 public class Command
 {
     internal Command() { }
     
-    public string Name { get; init; }
-    public Type Type { get; init; }
-    public string Value { get; init; }
+    public string? Name { get; init; }
+    public OptionType OptionType { get; init; }
+    public string? Value { get; init; }
 }
\ No newline at end of file
diff --git a/Simple.ArgumentParser/Constants.cs b/Simple.ArgumentParser/Constants.cs
new file mode 100644
index 0000000..a6d8234
--- /dev/null
+++ b/Simple.ArgumentParser/Constants.cs
@@ -0,0 +1,14 @@
+namespace Simple.ArgumentParser;
+
+internal static class Constants
+{
+    internal const string Pattern = @"(?<key>--\w+|-[a-zA-Z])(?:\s+(?<value>[^--]+))?(?=\s+--|\s+-|$)";
+    
+    internal const string LongPrefix = "--";
+    internal const string ShortPrefix = "-";
+
+    internal const string HelpOptionName = "help";
+    internal const string VersionOptionName = "version";
+    
+    internal const int HelpSectionTabLength = 2;
+}
\ No newline at end of file
diff --git a/Simple.ArgumentParser/Option.cs b/Simple.ArgumentParser/Option.cs
deleted file mode 100644
index cd0f29c..0000000
--- a/Simple.ArgumentParser/Option.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-namespace Simple.ArgumentParser;
-
-public class Option
-{
-    internal Option() { }
-    
-    public string Name { get; init; }
-    public string ShortName { get; init; }
-    public string Description { get; init; }
-    public Type Type { get; init; }
-    public bool Required { get; init; }
-}
\ No newline at end of file
diff --git a/Simple.ArgumentParser/Options/AlphaOption.cs b/Simple.ArgumentParser/Options/AlphaOption.cs
new file mode 100644
index 0000000..e09c6de
--- /dev/null
+++ b/Simple.ArgumentParser/Options/AlphaOption.cs
@@ -0,0 +1,23 @@
+using System.Runtime.CompilerServices;
+[assembly: InternalsVisibleTo("Simple.ArgumentParser.Tests")]
+
+namespace Simple.ArgumentParser.Options;
+
+internal class AlphaOption : Option
+{
+    protected internal override OptionType Type => OptionType.Alpha;
+
+    internal AlphaOption(string name, char shortName, string description, OptionSettings? settings = null)
+        : base(name, shortName, description, settings)
+    {
+    }
+
+    protected internal override bool ValueIsValid(string value, out string message)
+    {
+        message = string.IsNullOrEmpty(value)
+            ? $"Value '{value}' is invalid for Argument '{Name}' - expected a value of type '{Type}'"
+            : string.Empty;
+
+        return message == string.Empty;
+    }
+}
\ No newline at end of file
diff --git a/Simple.ArgumentParser/Options/BooleanOption.cs b/Simple.ArgumentParser/Options/BooleanOption.cs
new file mode 100644
index 0000000..1c94df7
--- /dev/null
+++ b/Simple.ArgumentParser/Options/BooleanOption.cs
@@ -0,0 +1,32 @@
+using System.Runtime.CompilerServices;
+[assembly: InternalsVisibleTo("Simple.ArgumentParser.Tests")]
+
+namespace Simple.ArgumentParser.Options;
+
+internal class BooleanOption : Option
+{
+    protected internal override OptionType Type => OptionType.Boolean;
+
+    internal BooleanOption(string name, char shortName, string description, OptionSettings? settings = null)
+        : base(name, shortName, description, settings)
+    {
+    }
+
+    protected internal override bool ValueIsValid(string value, out string message)
+    {
+        if (Settings.Strict)
+        {
+            message = value is "true" or "false"
+                ? string.Empty
+                : $"Value '{value}' is invalid for Argument '{Name}' - expected a value of type '{Type}' [true or false]";
+
+            return message == string.Empty;
+        }
+        
+        message = value is "1" or "0" or "true" or "false"
+            ? string.Empty
+            : $"Value '{value}' is invalid for Argument '{Name}' - expected a value of type '{Type}' [true or false, 1 or 0]";
+
+        return message == string.Empty;
+    }
+}
\ No newline at end of file
diff --git a/Simple.ArgumentParser/Options/CharOption.cs b/Simple.ArgumentParser/Options/CharOption.cs
new file mode 100644
index 0000000..e7723fe
--- /dev/null
+++ b/Simple.ArgumentParser/Options/CharOption.cs
@@ -0,0 +1,20 @@
+namespace Simple.ArgumentParser.Options;
+
+internal class CharOption : Option
+{
+    protected internal override OptionType Type => OptionType.Char;
+    
+    public CharOption(string name, char shortName, string description, OptionSettings? settings = null) 
+        : base(name, shortName, description, settings)
+    {
+    }
+
+    protected internal override bool ValueIsValid(string value, out string message)
+    {
+        message = char.TryParse(value, out _)
+            ? string.Empty
+            : $"Value '{value}' is invalid for Argument '{Name}' - expected a value of type '{Type}'";
+
+        return message == string.Empty;
+    }
+}
\ No newline at end of file
diff --git a/Simple.ArgumentParser/Options/DoubleOption.cs b/Simple.ArgumentParser/Options/DoubleOption.cs
new file mode 100644
index 0000000..d505a16
--- /dev/null
+++ b/Simple.ArgumentParser/Options/DoubleOption.cs
@@ -0,0 +1,22 @@
+using System.Globalization;
+
+namespace Simple.ArgumentParser.Options;
+
+internal class DoubleOption : Option
+{
+    protected internal override OptionType Type => OptionType.Double;
+
+    internal DoubleOption(string name, char shortName, string description, OptionSettings? settings = null)
+        : base(name, shortName, description, settings)
+    {
+    }
+
+    protected internal override bool ValueIsValid(string value, out string message)
+    {
+        message = double.TryParse(value, CultureInfo.InvariantCulture, out _)
+            ? string.Empty
+            : $"Value '{value}' is invalid for Argument '{Name}' - expected a value of type '{Type}'";
+
+        return message == string.Empty;
+    }
+}
\ No newline at end of file
diff --git a/Simple.ArgumentParser/Options/EnumerateOption.cs b/Simple.ArgumentParser/Options/EnumerateOption.cs
new file mode 100644
index 0000000..0abdb87
--- /dev/null
+++ b/Simple.ArgumentParser/Options/EnumerateOption.cs
@@ -0,0 +1,22 @@
+namespace Simple.ArgumentParser.Options;
+
+internal class EnumerateOption : Option
+{
+    private readonly string[] _accepted;
+    protected internal override OptionType Type => OptionType.Enumerate;
+    
+    public EnumerateOption(string name, char shortName, string description, string[] accepted, OptionSettings? settings = null) 
+        : base(name, shortName, description, settings)
+    {
+        _accepted = accepted;
+    }
+
+    protected internal override bool ValueIsValid(string value, out string message)
+    {
+        message = _accepted.Contains(value)
+            ? string.Empty
+            : $"Value '{value}' is invalid for Argument '{Name}' - expected one of: {string.Join(", ", _accepted)}";
+        
+        return message == string.Empty;
+    }
+}
\ No newline at end of file
diff --git a/Simple.ArgumentParser/Options/FlagOption.cs b/Simple.ArgumentParser/Options/FlagOption.cs
new file mode 100644
index 0000000..b6f4aa5
--- /dev/null
+++ b/Simple.ArgumentParser/Options/FlagOption.cs
@@ -0,0 +1,20 @@
+namespace Simple.ArgumentParser.Options;
+
+internal class FlagOption : Option
+{
+    protected internal override OptionType Type => OptionType.Flag;
+
+    internal FlagOption(string name, char shortName, string description, OptionSettings settings)
+        : base(name, shortName, description, settings)
+    {
+    }
+
+    protected internal override bool ValueIsValid(string value, out string message)
+    {
+        message = value != string.Empty
+            ? $"Argument '{Name}' is invalid - expected no value at all'"
+            : string.Empty;
+
+        return message == string.Empty;
+    }
+}
\ No newline at end of file
diff --git a/Simple.ArgumentParser/Options/HelpOption.cs b/Simple.ArgumentParser/Options/HelpOption.cs
new file mode 100644
index 0000000..344a8d7
--- /dev/null
+++ b/Simple.ArgumentParser/Options/HelpOption.cs
@@ -0,0 +1,17 @@
+namespace Simple.ArgumentParser.Options;
+
+internal class HelpOption : Option
+{
+    protected internal override OptionType Type => OptionType.Flag;
+    
+    internal HelpOption() : base(Constants.HelpOptionName, 'h', "Show this help section")
+    {
+    }
+
+    protected internal override bool ValueIsValid(string value, out string message)
+    {
+        // no-op
+        message = string.Empty;
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/Simple.ArgumentParser/Options/IntegerOption.cs b/Simple.ArgumentParser/Options/IntegerOption.cs
new file mode 100644
index 0000000..0fd2be5
--- /dev/null
+++ b/Simple.ArgumentParser/Options/IntegerOption.cs
@@ -0,0 +1,22 @@
+using System.Globalization;
+
+namespace Simple.ArgumentParser.Options;
+
+internal class IntegerOption : Option
+{
+    protected internal override OptionType Type => OptionType.Integer;
+
+    internal IntegerOption(string name, char shortName, string description, OptionSettings settings)
+        : base(name, shortName, description, settings)
+    {
+    }
+
+    protected internal override bool ValueIsValid(string value, out string message)
+    {
+        message = int.TryParse(value, out _)
+            ? string.Empty
+            : $"Value '{value}' is invalid for Argument '{Name}' - expected a value of type '{Type}'";
+        
+        return message == string.Empty;
+    }
+}
\ No newline at end of file
diff --git a/Simple.ArgumentParser/Options/Option.cs b/Simple.ArgumentParser/Options/Option.cs
new file mode 100644
index 0000000..27e9f2d
--- /dev/null
+++ b/Simple.ArgumentParser/Options/Option.cs
@@ -0,0 +1,23 @@
+using System.Runtime.CompilerServices;
+[assembly: InternalsVisibleTo("ProjectA")]
+
+namespace Simple.ArgumentParser.Options;
+
+internal abstract class Option
+{
+    internal Option(string name, char shortName, string description, OptionSettings? settings = null)
+    {
+        Name = Constants.LongPrefix + name;
+        ShortName = Constants.ShortPrefix + shortName;
+        Description = description;
+        Settings = settings ?? new OptionSettings();
+    }
+    
+    protected internal string Name { get; }
+    protected internal string ShortName { get; }
+    protected internal string Description { get; }
+    protected internal abstract OptionType Type { get; }
+    protected internal OptionSettings Settings { get; }
+
+    protected internal abstract bool ValueIsValid(string value, out string message);
+}
\ No newline at end of file
diff --git a/Simple.ArgumentParser/Options/OptionSettings.cs b/Simple.ArgumentParser/Options/OptionSettings.cs
new file mode 100644
index 0000000..d934e09
--- /dev/null
+++ b/Simple.ArgumentParser/Options/OptionSettings.cs
@@ -0,0 +1,7 @@
+namespace Simple.ArgumentParser.Options;
+
+internal class OptionSettings
+{
+    internal bool Strict { get; set; } = false;
+    internal bool Required { get; set; } = false;
+}
\ No newline at end of file
diff --git a/Simple.ArgumentParser/Options/OptionType.cs b/Simple.ArgumentParser/Options/OptionType.cs
new file mode 100644
index 0000000..737437a
--- /dev/null
+++ b/Simple.ArgumentParser/Options/OptionType.cs
@@ -0,0 +1,12 @@
+namespace Simple.ArgumentParser.Options;
+
+public enum OptionType
+{
+    Alpha = 0,
+    Char,
+    Integer,
+    Double,
+    Boolean,
+    Flag,
+    Enumerate
+}
\ No newline at end of file
diff --git a/Simple.ArgumentParser/Options/VersionOption.cs b/Simple.ArgumentParser/Options/VersionOption.cs
new file mode 100644
index 0000000..b382793
--- /dev/null
+++ b/Simple.ArgumentParser/Options/VersionOption.cs
@@ -0,0 +1,17 @@
+namespace Simple.ArgumentParser.Options;
+
+internal class VersionOption : Option
+{
+    protected internal override OptionType Type => OptionType.Flag;
+    
+    internal VersionOption() : base(Constants.VersionOptionName, 'v', "Show application version")
+    {
+    }
+
+    protected internal override bool ValueIsValid(string value, out string message)
+    {
+        // no-op
+        message = string.Empty;
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/Simple.ArgumentParser/Parser.cs b/Simple.ArgumentParser/Parser.cs
deleted file mode 100644
index 649b990..0000000
--- a/Simple.ArgumentParser/Parser.cs
+++ /dev/null
@@ -1,120 +0,0 @@
-using System.Diagnostics;
-using System.Reflection;
-using System.Text;
-using System.Text.RegularExpressions;
-using Simple.ArgumentParser.Builders;
-
-namespace Simple.ArgumentParser;
-
-public class Parser
-{
-    public readonly OptionsBuilder Options;
-
-    public Parser()
-    {
-        Options = new OptionsBuilder(this);
-    }
-
-    public Arguments Parse(string[] args)
-    {
-        var arguments = new Arguments(BuildHelpSection, Options.version);
-
-        if (Options.options.Count == 0) return arguments;
-
-        const string pattern = @"(?<key>--\w+|-[a-zA-Z])(?:\s+(?<value>[^--]+))?(?=\s+--|\s+-|$)";
-
-        var flatArgs = string.Join(" ", args);
-        foreach (Match match in Regex.Matches(flatArgs, pattern))
-        {
-            // Hämta nyckel och värde
-            var key = match.Groups["key"].Value;
-            var value = match.Groups["value"].Success
-                ? match.Groups["value"].Value.Trim()
-                : string.Empty;
-
-            var matchingOption = key.StartsWith("--")
-                ? Options.options.SingleOrDefault(o => o.Name == key)
-                : Options.options.SingleOrDefault(o => o.ShortName == key);
-
-            if (matchingOption is null) continue;
-
-            var errorMessage = string.Empty;
-            switch (matchingOption.Type)
-            {
-                case Type.Float:
-                    ValidateValueType(matchingOption, () => float.TryParse(value, out _), out errorMessage);
-                    break;
-                case Type.Integer:
-                    ValidateValueType(matchingOption, () => int.TryParse(value, out _), out errorMessage);
-                    break;
-                case Type.Boolean:
-                    ValidateValueType(matchingOption, () => bool.TryParse(value, out _), out errorMessage);
-                    break;
-                case Type.None:
-                    ValidateValueType(matchingOption, () => value == string.Empty, out errorMessage);
-                    break;
-                case Type.Alpha:
-                    ValidateValueType(matchingOption, () => value != string.Empty, out errorMessage);
-                    break;
-            }
-
-            if (errorMessage != string.Empty)
-            {
-                arguments.InvalidCommands.Add(errorMessage);
-                continue;
-            }
-
-            arguments.ValidCommands.Add(new Command { Value = value, Type = matchingOption.Type, Name = matchingOption.Name.TrimStart('-') });
-        }
-
-        var requiredOptionsMissing = Options.options
-            .Where(o => o.Required)
-            .Select(o => o.Name)
-            .Except(arguments.ValidCommands.Select(a => "--" + a.Name))
-            .ToList();
-
-        arguments.MissingCommands.AddRange(requiredOptionsMissing);
-        arguments.ShowHelpRequested = arguments.ValidCommands.Any(a => a.Name == "help");
-        arguments.ShowVersionRequested = arguments.ValidCommands.Any(a => a.Name == "version");
-        return arguments;
-    }
-
-    private string BuildHelpSection()
-    {
-        var executableName = Path.GetFileName(Process.GetCurrentProcess().MainModule?.FileName);
-        
-        var stringBuilder = new StringBuilder();
-        stringBuilder.AppendLine("Description:");
-        stringBuilder.AppendLine($"    {Options.description}");
-        stringBuilder.AppendLine();
-        stringBuilder.AppendLine("Usage:");
-        stringBuilder.AppendLine($"    {executableName ?? "<executable>"} [OPTIONS]");
-        stringBuilder.AppendLine();
-        stringBuilder.AppendLine("Options:");
-
-        var longestArgument = Options.options.Max(o => o.Name.Length);
-        var longestTypeName = Options.options.Max(o => o.Type.ToString().Length);
-        
-        foreach (var option in Options.options)
-        {
-            var key = $"    {option.Name.PadRight(longestArgument + 2, ' ')}{(option.ShortName != null ? $"{option.ShortName.PadRight(3, ' ')}" : string.Empty)}";
-            var type = $"{(option.Type != Type.None ? $"<{option.Type}>".PadRight(longestTypeName + 4) : "".PadRight(longestTypeName + 4))}";
-            
-            stringBuilder.Append($"{key} {type}".PadRight(40, ' '));
-            stringBuilder.Append($"{(option.Required ? "(required)" : "").PadRight(12, ' ')}");
-            stringBuilder.Append(option.Description);
-            stringBuilder.AppendLine();
-        }
-
-        return stringBuilder.ToString();
-    }
-
-    private void ValidateValueType(Option option, Func<bool> validation, out string message)
-    {
-        message = string.Empty;
-        if (validation() is false)
-        {
-            message = $"Argument '{option.Name}' is invalid - expected value type '{option.Type}'";
-        }
-    }
-}
\ No newline at end of file
diff --git a/Simple.ArgumentParser/Simple.ArgumentParser.csproj b/Simple.ArgumentParser/Simple.ArgumentParser.csproj
index c519981..e45c912 100644
--- a/Simple.ArgumentParser/Simple.ArgumentParser.csproj
+++ b/Simple.ArgumentParser/Simple.ArgumentParser.csproj
@@ -8,7 +8,7 @@
 
     <PropertyGroup>
         <PackageId>Simple.ArgumentParser</PackageId>
-        <Version>1.0.6</Version>
+        <Version>1.1.0</Version>
         <Authors>Henrik Larsson</Authors>
         <PackageProjectUrl>https://github.com/henkla/Simple.ArgumentParser</PackageProjectUrl>
         <RepositoryUrl>https://github.com/henkla/Simple.ArgumentParser</RepositoryUrl>
@@ -23,4 +23,8 @@
         <None Include="../README.md" Pack="true" PackagePath="" />
     </ItemGroup>
 
+    <ItemGroup>
+      <Folder Include="Properties\" />
+    </ItemGroup>
+
 </Project>
diff --git a/Simple.ArgumentParser/Type.cs b/Simple.ArgumentParser/Type.cs
deleted file mode 100644
index 8164998..0000000
--- a/Simple.ArgumentParser/Type.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-namespace Simple.ArgumentParser;
-
-public enum Type
-{
-    Alpha = 0,
-    Integer,
-    Float,
-    Boolean,
-    None
-}
\ No newline at end of file