### Access SemVersion Properties and State

Source: https://context7.com/walkercoderanger/semver/llms.txt

Retrieve core version numbers, prerelease information, and build metadata from a SemVersion object. Also demonstrates conversion to System.Version.

```csharp
using Semver;

var version = SemVersion.Parse("1.2.3-rc.1+build.456", SemVersionStyles.Strict);

// Core version numbers
Console.WriteLine($"Major: {version.Major}");       // 1
Console.WriteLine($"Minor: {version.Minor}");       // 2
Console.WriteLine($"Patch: {version.Patch}");       // 3

// Prerelease information
Console.WriteLine($"Prerelease: {version.Prerelease}"); // rc.1
Console.WriteLine($"IsPrerelease: {version.IsPrerelease}"); // True
Console.WriteLine($"IsRelease: {version.IsRelease}");       // False

// Access individual prerelease identifiers
foreach (var id in version.PrereleaseIdentifiers)
{
    Console.WriteLine($"  Identifier: {id.Value}, Numeric: {id.NumericValue}");
}
// Output:
//   Identifier: rc, Numeric: null
//   Identifier: 1, Numeric: 1

// Build metadata
Console.WriteLine($"Metadata: {version.Metadata}"); // build.456
foreach (var id in version.MetadataIdentifiers)
{
    Console.WriteLine($"  Metadata: {id.Value}");
}
// Output:
//   Metadata: build
//   Metadata: 456

// Convert to System.Version (release versions only)
var release = SemVersion.Parse("1.2.3", SemVersionStyles.Strict);
Version sysVersion = release.ToVersion();
Console.WriteLine(sysVersion); // 1.2.3
```

--------------------------------

### Construct Semantic Versions Programmatically

Source: https://context7.com/walkercoderanger/semver/llms.txt

Create SemVersion objects using constructors or factory methods. Supports prerelease and metadata identifiers. Can convert from System.Version.

```csharp
using Semver;

// Simple constructors
var v1 = new SemVersion(1);           // 1.0.0
var v2 = new SemVersion(1, 2);        // 1.2.0
var v3 = new SemVersion(1, 2, 3);     // 1.2.3

// Constructor with prerelease and metadata identifiers
var v4 = new SemVersion(2, 0, 0,
    prerelease: new[] { "alpha", "1" },
    metadata: new[] { "build", "001" });
Console.WriteLine(v4); // Output: 2.0.0-alpha.1+build.001

// Using ParsedFrom for string prerelease/metadata
var v5 = SemVersion.ParsedFrom(1, 1, 0, prerelease: "rc.1", metadata: "e471d15");
Console.WriteLine(v5); // Output: 1.1.0-rc.1+e471d15

// From System.Version
var sysVersion = new Version(3, 2, 1);
var semVer = SemVersion.FromVersion(sysVersion);
Console.WriteLine(semVer); // Output: 3.2.1
```

--------------------------------

### Semver.SemVersion Methods

Source: https://github.com/walkercoderanger/semver/blob/master/Semver/PublicAPI/net5.0/PublicAPI.Shipped.txt

Provides documentation for the methods and properties of the SemVersion class.

```APIDOC
## Semver.SemVersion

### Description
Represents a semantic version.

### Methods
- **Equals**(object? obj) -> bool
- **GetHashCode**() -> int
- **ToString**() -> string!
- **ComparePrecedenceTo**(Semver.SemVersion? other) -> int
- **CompareSortOrderTo**(Semver.SemVersion? other) -> int
- **Equals**(Semver.SemVersion? other) -> bool
- **GetObjectData**(System.Runtime.Serialization.SerializationInfo! info, System.Runtime.Serialization.StreamingContext context) -> void
- **PrecedenceEquals**(Semver.SemVersion? other) -> bool
- **Satisfies**(Semver.SemVersionRange! range) -> bool
- **Satisfies**(Semver.UnbrokenSemVersionRange! range) -> bool
- **Satisfies**(string! range, int maxLength = 2048) -> bool
- **Satisfies**(string! range, Semver.SemVersionRangeOptions options, int maxLength = 2048) -> bool
- **Satisfies**(System.Predicate<Semver.SemVersion!>! predicate) -> bool
- **SatisfiesNpm**(string! range, bool includeAllPrerelease, int maxLength = 2048) -> bool
- **SatisfiesNpm**(string! range, int maxLength = 2048) -> bool
- **SemVersion**(System.Numerics.BigInteger major) -> void
- **SemVersion**(System.Numerics.BigInteger major, System.Numerics.BigInteger minor = default(System.Numerics.BigInteger), System.Numerics.BigInteger patch = default(System.Numerics.BigInteger), System.Collections.Generic.IEnumerable<Semver.PrereleaseIdentifier>? prerelease = null, System.Collections.Generic.IEnumerable<Semver.MetadataIdentifier>? metadata = null) -> void
- **SemVersion**(System.Numerics.BigInteger major, System.Numerics.BigInteger minor = default(System.Numerics.BigInteger), System.Numerics.BigInteger patch = default(System.Numerics.BigInteger), System.Collections.Generic.IEnumerable<string!>? prerelease = null, System.Collections.Generic.IEnumerable<string!>? metadata = null) -> void
- **SemVersion**(System.Numerics.BigInteger major, System.Numerics.BigInteger minor) -> void
- **SemVersion**(System.Numerics.BigInteger major, System.Numerics.BigInteger minor, System.Numerics.BigInteger patch) -> void
- **ToVersion**() -> System.Version!

### Properties
- **IsPrerelease**.get -> bool
- **IsRelease**.get -> bool
- **Major**.get -> System.Numerics.BigInteger
- **Metadata**.get -> string!
- **MetadataIdentifiers**.get -> System.Collections.Generic.IReadOnlyList<Semver.MetadataIdentifier>!
- **Minor**.get -> System.Numerics.BigInteger
- **Patch**.get -> System.Numerics.BigInteger
- **Prerelease**.get -> string!
- **PrereleaseIdentifiers**.get -> System.Collections.Generic.IReadOnlyList<Semver.PrereleaseIdentifier>!
```

--------------------------------

### Semver.SemVersionRange Methods

Source: https://github.com/walkercoderanger/semver/blob/master/Semver/PublicAPI/net5.0/PublicAPI.Shipped.txt

Provides documentation for the methods and properties of the SemVersionRange class.

```APIDOC
## Semver.SemVersionRange

### Description
Represents a range of semantic versions.

### Methods
- **Equals**(object? obj) -> bool
- **GetHashCode**() -> int
- **ToString**() -> string!
```

--------------------------------

### Parse Semver Ranges (npm Syntax)

Source: https://context7.com/walkercoderanger/semver/llms.txt

Parse version ranges using npm-compatible syntax, including caret, tilde, wildcards, hyphen ranges, and union operators. Control prerelease inclusion with the includeAllPrerelease flag.

```csharp
using Semver;

// Parse npm-style ranges
var range1 = SemVersionRange.ParseNpm("^1.2.3");        // >=1.2.3 <2.0.0
var range2 = SemVersionRange.ParseNpm("~1.2.3");        // >=1.2.3 <1.3.0
var range3 = SemVersionRange.ParseNpm("1.2.x");         // >=1.2.0 <1.3.0
var range4 = SemVersionRange.ParseNpm("1.2.3 - 2.3.4"); // >=1.2.3 <=2.3.4
var range5 = SemVersionRange.ParseNpm(">=1.0.0 <2.0.0 || >=3.0.0"); // Union

// Include all prerelease versions in range
var prereleaseRange = SemVersionRange.ParseNpm("^1.0.0", includeAllPrerelease: true);
var beta = SemVersion.Parse("1.5.0-beta.1", SemVersionStyles.Strict);
Console.WriteLine(prereleaseRange.Contains(beta)); // True

// Without includeAllPrerelease, only prereleases matching bounds are included
var strictRange = SemVersionRange.ParseNpm("^1.0.0-alpha");
var alpha = SemVersion.Parse("1.0.0-alpha.2", SemVersionStyles.Strict);
var otherBeta = SemVersion.Parse("1.5.0-beta", SemVersionStyles.Strict);
Console.WriteLine(strictRange.Contains(alpha));     // True (matches 1.0.0)
Console.WriteLine(strictRange.Contains(otherBeta)); // False

// Safe parsing
if (SemVersionRange.TryParseNpm(">=1.0.0", out var parsed))
{
    Console.WriteLine($"Parsed: {parsed}");
}

```

--------------------------------

### Construct a Semantic Version

Source: https://github.com/walkercoderanger/semver/blob/master/Semver/README.md

Create SemVersion objects using constructors or helper methods like ParsedFrom for specific parts of a version.

```csharp
var v1 = new SemVersion(1, 0);
```

```csharp
var vNextRc = SemVersion.ParsedFrom(1, 1, 0, "rc.1");
```

--------------------------------

### Compare Semantic Versions

Source: https://github.com/walkercoderanger/semver/blob/master/Semver/README.md

Compare semantic versions using ComparePrecedenceTo for version precedence and CompareSortOrderTo for sorting order.

```csharp
if (version.ComparePrecedenceTo(vNextRc) == 0)
    Console.WriteLine($"{version} has the same precedence as {vNextRc}");
```

```csharp
if (version.CompareSortOrderTo(vNextRc) > 0)
    Console.WriteLine($"{version} sorts after {vNextRc}");
```

--------------------------------

### Semver.PrereleaseIdentifier Methods

Source: https://github.com/walkercoderanger/semver/blob/master/Semver/PublicAPI/net5.0/PublicAPI.Shipped.txt

Provides documentation for the methods and properties of the PrereleaseIdentifier class.

```APIDOC
## Semver.PrereleaseIdentifier

### Description
Represents a prerelease identifier in a semantic version.

### Methods
- **Equals**(object? value) -> bool
- **GetHashCode**() -> int
- **ToString**() -> string!
- **CompareTo**(object? value) -> int
- **CompareTo**(Semver.PrereleaseIdentifier value) -> int
- **Equals**(Semver.PrereleaseIdentifier value) -> bool
- **PrereleaseIdentifier**() -> void
- **PrereleaseIdentifier**(string! value, bool allowLeadingZeros = false) -> void
- **PrereleaseIdentifier**(System.Numerics.BigInteger value) -> void

### Properties
- **NumericValue**.get -> System.Numerics.BigInteger?
- **Value**.get -> string!
```

--------------------------------

### Work with UnbrokenSemVersionRange

Source: https://context7.com/walkercoderanger/semver/llms.txt

Create and manipulate continuous version ranges. This includes checking containment, using predefined ranges, and converting ranges to predicates.

```csharp
using Semver;

var v1 = SemVersion.Parse("1.0.0", SemVersionStyles.Strict);
var v2 = SemVersion.Parse("2.0.0", SemVersionStyles.Strict);

// Create unbroken ranges
var range = UnbrokenSemVersionRange.Inclusive(v1, v2);
Console.WriteLine($"Start: {range.Start}, StartInclusive: {range.StartInclusive}");
Console.WriteLine($"End: {range.End}, EndInclusive: {range.EndInclusive}");
Console.WriteLine($"IncludeAllPrerelease: {range.IncludeAllPrerelease}");

// Check containment
var test = SemVersion.Parse("1.5.0", SemVersionStyles.Strict);
Console.WriteLine(range.Contains(test)); // True

// Predefined unbroken ranges
var empty = UnbrokenSemVersionRange.Empty;
var all = UnbrokenSemVersionRange.All;
var allRelease = UnbrokenSemVersionRange.AllRelease;

// Convert to predicate
Predicate<SemVersion> predicate = range;
Console.WriteLine(predicate(test)); // True

// Iterate through SemVersionRange (composed of UnbrokenSemVersionRange)
var compositeRange = SemVersionRange.Parse(">=1.0.0 <2.0.0 || >=3.0.0");
Console.WriteLine($"Range has {compositeRange.Count} unbroken ranges");
foreach (var unbroken in compositeRange)
{
    Console.WriteLine($"  {unbroken}");
}
```

--------------------------------

### Create SemVersion Ranges Programmatically

Source: https://context7.com/walkercoderanger/semver/llms.txt

Use factory methods to build version ranges instead of parsing strings. This is useful for creating complex or dynamic version constraints.

```csharp
using Semver;

var v1 = SemVersion.Parse("1.0.0", SemVersionStyles.Strict);
var v2 = SemVersion.Parse("2.0.0", SemVersionStyles.Strict);

// Single version
var exact = SemVersionRange.Equals(v1);           // =1.0.0

// Comparison ranges
var atLeast = SemVersionRange.AtLeast(v1);        // >=1.0.0
var greaterThan = SemVersionRange.GreaterThan(v1); // >1.0.0
var atMost = SemVersionRange.AtMost(v2);          // <=2.0.0
var lessThan = SemVersionRange.LessThan(v2);      // <2.0.0

// Bounded ranges
var inclusive = SemVersionRange.Inclusive(v1, v2);      // >=1.0.0 <=2.0.0
var exclusive = SemVersionRange.Exclusive(v1, v2);      // >1.0.0 <2.0.0
var startInclusive = SemVersionRange.InclusiveOfStart(v1, v2); // >=1.0.0 <2.0.0
var endInclusive = SemVersionRange.InclusiveOfEnd(v1, v2);     // >1.0.0 <=2.0.0

// Include all prerelease
var withPrerelease = SemVersionRange.AtLeast(v1, includeAllPrerelease: true);

// Combine multiple unbroken ranges
var union = SemVersionRange.Create(
    UnbrokenSemVersionRange.LessThan(v1),
    UnbrokenSemVersionRange.GreaterThan(v2)
);

// Predefined ranges
var empty = SemVersionRange.Empty;         // No versions
var all = SemVersionRange.All;             // All versions including prerelease
var allRelease = SemVersionRange.AllRelease; // All release versions only
```

--------------------------------

### SemVersion Parsing and Creation

Source: https://github.com/walkercoderanger/semver/blob/master/Semver/PublicAPI/netstandard2.0/PublicAPI.Shipped.txt

Provides methods for parsing version strings into Semver.SemVersion objects and creating new Semver.SemVersion objects from various inputs.

```APIDOC
## SemVersion Parsing and Creation

### Description
Methods for parsing version strings and creating Semver.SemVersion objects.

### Methods

#### `Semver.SemVersion.Parse(string version, int maxLength = 1024)`
Parses a semantic version string.

#### `Semver.SemVersion.Parse(string version, Semver.SemVersionStyles style, int maxLength = 1024)`
Parses a semantic version string with specified styles.

#### `Semver.SemVersion.TryParse(string? version, out Semver.SemVersion? semver, int maxLength = 1024)`
Attempts to parse a semantic version string.

#### `Semver.SemVersion.TryParse(string? version, Semver.SemVersionStyles style, out Semver.SemVersion? semver, int maxLength = 1024)`
Attempts to parse a semantic version string with specified styles.

#### `Semver.SemVersion.FromVersion(System.Version version)`
Creates a Semver.SemVersion from a System.Version.

#### `Semver.SemVersion.ParsedFrom(System.Numerics.BigInteger major, System.Numerics.BigInteger? minor = null, System.Numerics.BigInteger? patch = null, string prerelease = "", string metadata = "", bool allowLeadingZeros = false)`
Creates a Semver.SemVersion from major, minor, patch, prerelease, and metadata components.
```

--------------------------------

### Compare Semantic Versions

Source: https://context7.com/walkercoderanger/semver/llms.txt

Compare versions by precedence (ignores metadata) or sort order (includes metadata). Static methods and instance methods are available. Equality checks require exact matches.

```csharp
using Semver;

var v1 = SemVersion.Parse("1.0.0", SemVersionStyles.Strict);
var v2 = SemVersion.Parse("1.0.0-alpha", SemVersionStyles.Strict);
var v3 = SemVersion.Parse("1.0.0+build1", SemVersionStyles.Strict);
var v4 = SemVersion.Parse("1.0.0+build2", SemVersionStyles.Strict);

// Precedence comparison (metadata ignored)
Console.WriteLine(v1.ComparePrecedenceTo(v2)); // 1 (release > prerelease)
Console.WriteLine(v3.ComparePrecedenceTo(v4)); // 0 (same precedence)
Console.WriteLine(v1.PrecedenceEquals(v3));    // True

// Sort order comparison (metadata included)
Console.WriteLine(v3.CompareSortOrderTo(v4)); // -1 (build1 < build2)

// Static comparison methods
Console.WriteLine(SemVersion.ComparePrecedence(v1, v2)); // 1
Console.WriteLine(SemVersion.CompareSortOrder(v3, v4));  // -1

// Equality (exact match including metadata)
Console.WriteLine(v3 == v4);           // False
Console.WriteLine(v3.Equals(v4));      // False
Console.WriteLine(v1.Equals(v3));      // False (different metadata)
```

--------------------------------

### Parse SemVersionRange with Options

Source: https://context7.com/walkercoderanger/semver/llms.txt

Configure SemVer range parsing and behavior using option flags. `Strict` enforces standard range parsing. `IncludeAllPrerelease` ensures prerelease versions are considered within ranges. `AllowMetadata` permits versions with build metadata, though it's ignored for comparison. `AllowV` accepts 'v' prefixes, `AllowLeadingZeros` permits leading zeros on version components, and `OptionalPatch`/`OptionalMinorPatch` allow for abbreviated version specifications. `Loose` combines common permissive options. Options can be combined using the bitwise OR operator.

```csharp
using Semver;

// Strict: Standard SemVer range parsing
SemVersionRange.Parse(">=1.0.0 <2.0.0", SemVersionRangeOptions.Strict);
```

```csharp
// IncludeAllPrerelease: Include all prerelease versions in range
var range = SemVersionRange.Parse(">=1.0.0", SemVersionRangeOptions.IncludeAllPrerelease);
var beta = SemVersion.Parse("1.5.0-beta", SemVersionStyles.Strict);
Console.WriteLine(range.Contains(beta)); // True
```

```csharp
// AllowMetadata: Accept versions with metadata (metadata is ignored)
SemVersionRange.Parse(">=1.0.0+build", SemVersionRangeOptions.AllowMetadata);
```

```csharp
// AllowV: Accept v prefix on versions
SemVersionRange.Parse(">=v1.0.0", SemVersionRangeOptions.AllowV);
```

```csharp
// AllowLeadingZeros: Accept leading zeros on versions
SemVersionRange.Parse(">=01.0.0", SemVersionRangeOptions.AllowLeadingZeros);
```

```csharp
// OptionalPatch / OptionalMinorPatch
SemVersionRange.Parse(">=1.0", SemVersionRangeOptions.OptionalPatch);
SemVersionRange.Parse(">=1", SemVersionRangeOptions.OptionalMinorPatch);
```

```csharp
// Loose: Combine common permissive options
var looseRange = SemVersionRange.Parse(">=v01.0", SemVersionRangeOptions.Loose);
```

```csharp
// Combine multiple options
var options = SemVersionRangeOptions.AllowV |
              SemVersionRangeOptions.IncludeAllPrerelease |
              SemVersionRangeOptions.OptionalPatch;
SemVersionRange.Parse(">=v1.0", options);
```

--------------------------------

### Sort and Find Max/Min SemVersions

Source: https://github.com/walkercoderanger/semver/blob/master/Semver/README.md

Use SemVersion.SortOrderComparer or SemVersion.PrecedenceComparer with LINQ methods like OrderBy, ThenBy, Max, or Min to sort and find extreme versions.

```csharp
var examples = new List<Example> { ... };
// Put in sort order
var sorted = examples.OrderBy(e => e.Version, SemVersion.SortOrderComparer);
```

```csharp
// Order by precedence, then by release date
var ordered = examples.OrderBy(e => e.Version, SemVersion.PrecedenceComparer)
                      .ThenBy(e => e.Released);
```

```csharp
var versions = new List<SemVersion> { vNextRc, v1 };
var max = versions.Max(SemVersion.SortOrderComparer);
console.WriteLine($"Max version is {max}");
```

--------------------------------

### Semver.UnbrokenSemVersionRange Methods

Source: https://github.com/walkercoderanger/semver/blob/master/Semver/PublicAPI/net5.0/PublicAPI.Shipped.txt

Provides documentation for the methods and properties of the UnbrokenSemVersionRange class.

```APIDOC
## Semver.UnbrokenSemVersionRange

### Description
Represents an unbroken range of semantic versions.

### Methods
- **Equals**(object? obj) -> bool
- **GetHashCode**() -> int
- **ToString**() -> string!
```

--------------------------------

### Parse Semantic Version Strings

Source: https://context7.com/walkercoderanger/semver/llms.txt

Use SemVersion.Parse with SemVersionStyles for strict or flexible parsing. TryParse offers a safe alternative. Leading zeros are handled.

```csharp
using Semver;

// Strict parsing (SemVer 2.0 compliant)
var version = SemVersion.Parse("1.2.3-rc.1+build.456", SemVersionStyles.Strict);
Console.WriteLine($"Major: {version.Major}, Minor: {version.Minor}, Patch: {version.Patch}");
// Output: Major: 1, Minor: 2, Patch: 3

// Flexible parsing with options
var flexVersion = SemVersion.Parse("v1.2", SemVersionStyles.AllowV | SemVersionStyles.OptionalPatch);
Console.WriteLine(flexVersion); // Output: 1.2.0

// Safe parsing with TryParse
if (SemVersion.TryParse("2.0.0-beta", SemVersionStyles.Strict, out var parsed))
{
    Console.WriteLine($"Parsed: {parsed}");
}

// Parse with leading zeros allowed (zeros are removed)
var withZeros = SemVersion.Parse("01.02.03", SemVersionStyles.AllowLeadingZeros);
Console.WriteLine(withZeros); // Output: 1.2.3
```

--------------------------------

### UnbrokenSemVersionRange Properties and Static Methods

Source: https://github.com/walkercoderanger/semver/blob/master/Semver/PublicAPI/net5.0/PublicAPI.Shipped.txt

Provides access to predefined unbroken version ranges and static methods for creating new ones.

```APIDOC
## UnbrokenSemVersionRange.All

### Description
Gets an unbroken version range that includes all possible versions.

### Method
`static Semver.UnbrokenSemVersionRange.All.get`

### Returns
`Semver.UnbrokenSemVersionRange!` - An unbroken version range representing all versions.

## UnbrokenSemVersionRange.AllRelease

### Description
Gets an unbroken version range that includes all release versions (excluding prereleases).

### Method
`static Semver.UnbrokenSemVersionRange.AllRelease.get`

### Returns
`Semver.UnbrokenSemVersionRange!` - An unbroken version range representing all release versions.

## UnbrokenSemVersionRange.AtLeast

### Description
Creates an unbroken version range that is at least the specified version.

### Method
`static Semver.UnbrokenSemVersionRange.AtLeast(Semver.SemVersion! version, bool includeAllPrerelease = false)`

### Parameters
- **version** (Semver.SemVersion!) - Required - The minimum version.
- **includeAllPrerelease** (bool) - Optional - Whether to include prerelease versions. Defaults to false.

### Returns
`Semver.UnbrokenSemVersionRange!` - An unbroken version range.

## UnbrokenSemVersionRange.AtMost

### Description
Creates an unbroken version range that is at most the specified version.

### Method
`static Semver.UnbrokenSemVersionRange.AtMost(Semver.SemVersion! version, bool includeAllPrerelease = false)`

### Parameters
- **version** (Semver.SemVersion!) - Required - The maximum version.
- **includeAllPrerelease** (bool) - Optional - Whether to include prerelease versions. Defaults to false.

### Returns
`Semver.UnbrokenSemVersionRange!` - An unbroken version range.

## UnbrokenSemVersionRange.Empty

### Description
Gets an empty unbroken version range.

### Method
`static Semver.UnbrokenSemVersionRange.Empty.get`

### Returns
`Semver.UnbrokenSemVersionRange!` - An empty unbroken version range.

## UnbrokenSemVersionRange.Equals

### Description
Creates an unbroken version range that exactly matches the specified version.

### Method
`static Semver.UnbrokenSemVersionRange.Equals(Semver.SemVersion! version)`

### Parameters
- **version** (Semver.SemVersion!) - Required - The version to match exactly.

### Returns
`Semver.UnbrokenSemVersionRange!` - An unbroken version range matching the specified version.

## UnbrokenSemVersionRange.Exclusive

### Description
Creates an unbroken version range between two versions, exclusive of the start and end versions.

### Method
`static Semver.UnbrokenSemVersionRange.Exclusive(Semver.SemVersion! start, Semver.SemVersion! end, bool includeAllPrerelease = false)`

### Parameters
- **start** (Semver.SemVersion!) - Required - The starting version (exclusive).
- **end** (Semver.SemVersion!) - Required - The ending version (exclusive).
- **includeAllPrerelease** (bool) - Optional - Whether to include prerelease versions. Defaults to false.

### Returns
`Semver.UnbrokenSemVersionRange!` - An unbroken version range.

## UnbrokenSemVersionRange.GreaterThan

### Description
Creates an unbroken version range that is strictly greater than the specified version.

### Method
`static Semver.UnbrokenSemVersionRange.GreaterThan(Semver.SemVersion! version, bool includeAllPrerelease = false)`

### Parameters
- **version** (Semver.SemVersion!) - Required - The version to be greater than.
- **includeAllPrerelease** (bool) - Optional - Whether to include prerelease versions. Defaults to false.

### Returns
`Semver.UnbrokenSemVersionRange!` - An unbroken version range.

## UnbrokenSemVersionRange.implicit operator Predicate<Semver.SemVersion>

### Description
Implicitly converts an UnbrokenSemVersionRange to a Predicate<Semver.SemVersion>.

### Method
`static Semver.UnbrokenSemVersionRange.implicit operator System.Predicate<Semver.SemVersion!>!(Semver.UnbrokenSemVersionRange! range)`

### Parameters
- **range** (Semver.UnbrokenSemVersionRange!) - Required - The unbroken version range to convert.

### Returns
`System.Predicate<Semver.SemVersion!>` - A predicate function.

## UnbrokenSemVersionRange.Inclusive

### Description
Creates an unbroken version range between two versions, inclusive of both start and end versions.

### Method
`static Semver.UnbrokenSemVersionRange.Inclusive(Semver.SemVersion! start, Semver.SemVersion! end, bool includeAllPrerelease = false)`

### Parameters
- **start** (Semver.SemVersion!) - Required - The starting version (inclusive).
- **end** (Semver.SemVersion!) - Required - The ending version (inclusive).
- **includeAllPrerelease** (bool) - Optional - Whether to include prerelease versions. Defaults to false.

### Returns
`Semver.UnbrokenSemVersionRange!` - An unbroken version range.

## UnbrokenSemVersionRange.InclusiveOfEnd

### Description
Creates an unbroken version range between two versions, inclusive of the end version but exclusive of the start version.

### Method
`static Semver.UnbrokenSemVersionRange.InclusiveOfEnd(Semver.SemVersion! start, Semver.SemVersion! end, bool includeAllPrerelease = false)`

### Parameters
- **start** (Semver.SemVersion!) - Required - The starting version (exclusive).
- **end** (Semver.SemVersion!) - Required - The ending version (inclusive).
- **includeAllPrerelease** (bool) - Optional - Whether to include prerelease versions. Defaults to false.

### Returns
`Semver.UnbrokenSemVersionRange!` - An unbroken version range.

## UnbrokenSemVersionRange.InclusiveOfStart

### Description
Creates an unbroken version range between two versions, inclusive of the start version but exclusive of the end version.

### Method
`static Semver.UnbrokenSemVersionRange.InclusiveOfStart(Semver.SemVersion! start, Semver.SemVersion! end, bool includeAllPrerelease = false)`

### Parameters
- **start** (Semver.SemVersion!) - Required - The starting version (inclusive).
- **end** (Semver.SemVersion!) - Required - The ending version (exclusive).
- **includeAllPrerelease** (bool) - Optional - Whether to include prerelease versions. Defaults to false.

### Returns
`Semver.UnbrokenSemVersionRange!` - An unbroken version range.

## UnbrokenSemVersionRange.LessThan

### Description
Creates an unbroken version range that is strictly less than the specified version.

### Method
`static Semver.UnbrokenSemVersionRange.LessThan(Semver.SemVersion! version, bool includeAllPrerelease = false)`

### Parameters
- **version** (Semver.SemVersion!) - Required - The version to be less than.
- **includeAllPrerelease** (bool) - Optional - Whether to include prerelease versions. Defaults to false.

### Returns
`Semver.UnbrokenSemVersionRange!` - An unbroken version range.

## UnbrokenSemVersionRange.operator !=

### Description
Compares two unbroken version ranges for inequality.

### Method
`static Semver.UnbrokenSemVersionRange.operator !=(Semver.UnbrokenSemVersionRange? left, Semver.UnbrokenSemVersionRange? right)`

### Parameters
- **left** (Semver.UnbrokenSemVersionRange?) - The left operand.
- **right** (Semver.UnbrokenSemVersionRange?) - The right operand.

### Returns
`bool` - True if the ranges are not equal, false otherwise.

## UnbrokenSemVersionRange.operator ==

### Description
Compares two unbroken version ranges for equality.

### Method
`static Semver.UnbrokenSemVersionRange.operator ==(Semver.UnbrokenSemVersionRange? left, Semver.UnbrokenSemVersionRange? right)`

### Parameters
- **left** (Semver.UnbrokenSemVersionRange?) - The left operand.
- **right** (Semver.UnbrokenSemVersionRange?) - The right operand.

### Returns
`bool` - True if the ranges are equal, false otherwise.
```

--------------------------------

### SemVersion Class

Source: https://github.com/walkercoderanger/semver/blob/master/Semver/PublicAPI/netstandard2.0/PublicAPI.Shipped.txt

Details on the SemVersion class, its properties, constructors, and methods for version comparison and satisfaction.

```APIDOC
## SemVersion Class

### Description
Represents a Semantic Version (SemVer) with major, minor, patch, prerelease, and metadata components.

### Properties
- **Major** (System.Numerics.BigInteger) - The major version number.
- **Minor** (System.Numerics.BigInteger) - The minor version number.
- **Patch** (System.Numerics.BigInteger) - The patch version number.
- **Prerelease** (string!) - The prerelease version string.
- **PrereleaseIdentifiers** (System.Collections.Generic.IReadOnlyList<Semver.PrereleaseIdentifier>!) - A list of prerelease identifiers.
- **Metadata** (string!) - The metadata version string.
- **MetadataIdentifiers** (System.Collections.Generic.IReadOnlyList<Semver.MetadataIdentifier>!) - A list of metadata identifiers.
- **IsPrerelease** (bool) - True if the version is a prerelease version.
- **IsRelease** (bool) - True if the version is a release version.

### Constructors
- **SemVersion**(System.Numerics.BigInteger major)
- **SemVersion**(System.Numerics.BigInteger major, System.Numerics.BigInteger minor)
- **SemVersion**(System.Numerics.BigInteger major, System.Numerics.BigInteger minor, System.Numerics.BigInteger patch)
- **SemVersion**(System.Numerics.BigInteger major, System.Numerics.BigInteger minor = default(System.Numerics.BigInteger), System.Numerics.BigInteger patch = default(System.Numerics.BigInteger), System.Collections.Generic.IEnumerable<Semver.PrereleaseIdentifier>? prerelease = null, System.Collections.Generic.IEnumerable<Semver.MetadataIdentifier>? metadata = null)
- **SemVersion**(System.Numerics.BigInteger major, System.Numerics.BigInteger minor = default(System.Numerics.BigInteger), System.Numerics.BigInteger patch = default(System.Numerics.BigInteger), System.Collections.Generic.IEnumerable<string!>? prerelease = null, System.Collections.Generic.IEnumerable<string!>? metadata = null)

### Methods
- **Equals**(Semver.SemVersion? other) -> bool
- **PrecedenceEquals**(Semver.SemVersion? other) -> bool
- **ComparePrecedenceTo**(Semver.SemVersion? other) -> int
- **CompareSortOrderTo**(Semver.SemVersion? other) -> int
- **Satisfies**(Semver.SemVersionRange! range) -> bool
- **Satisfies**(Semver.UnbrokenSemVersionRange! range) -> bool
- **Satisfies**(string! range, int maxLength = 2048) -> bool
- **Satisfies**(string! range, Semver.SemVersionRangeOptions options, int maxLength = 2048) -> bool
- **Satisfies**(System.Predicate<Semver.SemVersion!>! predicate) -> bool
- **SatisfiesNpm**(string! range, int maxLength = 2048) -> bool
- **SatisfiesNpm**(string! range, bool includeAllPrerelease, int maxLength = 2048) -> bool
- **GetObjectData**(System.Runtime.Serialization.SerializationInfo! info, System.Runtime.Serialization.StreamingContext context) -> void
- **ToString**() -> string!
- **GetHashCode**() -> int
- **Equals**(object? obj) -> bool
- **ToVersion**() -> System.Version!
```

--------------------------------

### SemVersionStyles

Source: https://github.com/walkercoderanger/semver/blob/master/Semver/PublicAPI/netstandard2.0/PublicAPI.Shipped.txt

Enumeration for configuring SemVersion parsing.

```APIDOC
## SemVersionStyles

### Description
Defines styles and options for parsing semantic version strings.

### Styles
- **AllowLeadingWhitespace** (2): Allows leading whitespace.
- **AllowLeadingZeros** (1): Allows leading zeros in version components.
- **AllowLowerV** (8): Allows the prefix 'v' (lowercase) for versions.
- **AllowTrailingWhitespace** (4): Allows trailing whitespace.
- **AllowUpperV** (16): Allows the prefix 'V' (uppercase) for versions.
- **AllowV** (AllowLowerV | AllowUpperV): Allows both lowercase and uppercase 'v' prefixes.
- **AllowWhitespace** (AllowLeadingWhitespace | AllowTrailingWhitespace): Allows leading and trailing whitespace.
- **Any** (-1): Represents all possible styles.
- **OptionalMinorPatch** (96): Makes minor and patch versions optional.
- **OptionalPatch** (32): Makes the patch version optional.
- **Strict** (0): Strict parsing rules, no extra allowances.
```

--------------------------------

### Sort and Find Max/Min Versions

Source: https://context7.com/walkercoderanger/semver/llms.txt

Sort collections of SemVersion objects using SemVersion.PrecedenceComparer or SemVersion.SortOrderComparer. Use LINQ's Max/Min with comparers to find extreme versions.

```csharp
using Semver;
using System.Linq;

var versions = new List<SemVersion>
{
    SemVersion.Parse("2.0.0", SemVersionStyles.Strict),
    SemVersion.Parse("1.0.0", SemVersionStyles.Strict),
    SemVersion.Parse("1.1.0-alpha", SemVersionStyles.Strict),
    SemVersion.Parse("1.1.0", SemVersionStyles.Strict),
    SemVersion.Parse("1.0.0+build", SemVersionStyles.Strict)
};

// Sort by precedence (ignores metadata)
var byPrecedence = versions.OrderBy(v => v, SemVersion.PrecedenceComparer).ToList();
// Result: 1.0.0, 1.0.0+build, 1.1.0-alpha, 1.1.0, 2.0.0

// Sort by sort order (includes metadata)
var bySortOrder = versions.OrderBy(v => v, SemVersion.SortOrderComparer).ToList();
// Result: 1.0.0, 1.0.0+build, 1.1.0-alpha, 1.1.0, 2.0.0

// Find max/min versions
var maxVersion = versions.Max(SemVersion.PrecedenceComparer);
var minVersion = versions.Min(SemVersion.SortOrderComparer);
Console.WriteLine($"Max: {maxVersion}, Min: {minVersion}");
// Output: Max: 2.0.0, Min: 1.0.0
```

--------------------------------

### Semver.MetadataIdentifier Methods

Source: https://github.com/walkercoderanger/semver/blob/master/Semver/PublicAPI/net5.0/PublicAPI.Shipped.txt

Provides documentation for the methods and properties of the MetadataIdentifier class.

```APIDOC
## Semver.MetadataIdentifier

### Description
Represents a metadata identifier in a semantic version.

### Methods
- **Equals**(object? value) -> bool
- **GetHashCode**() -> int
- **ToString**() -> string!
- **CompareTo**(object? value) -> int
- **CompareTo**(Semver.MetadataIdentifier value) -> int
- **Equals**(Semver.MetadataIdentifier value) -> bool
- **MetadataIdentifier**() -> void
- **MetadataIdentifier**(string! value) -> void

### Properties
- **Value**.get -> string!
```

--------------------------------

### SemVersionRangeOptions

Source: https://github.com/walkercoderanger/semver/blob/master/Semver/PublicAPI/netstandard2.0/PublicAPI.Shipped.txt

Enumeration for configuring SemVersionRange parsing and comparison.

```APIDOC
## SemVersionRangeOptions

### Description
Defines options for parsing and interpreting semantic version ranges.

### Options
- **AllowLeadingZeros** (1): Allows leading zeros in version components.
- **AllowLowerV** (8): Allows the prefix 'v' (lowercase) for versions.
- **AllowMetadata** (4): Allows metadata in version strings.
- **AllowUpperV** (16): Allows the prefix 'V' (uppercase) for versions.
- **AllowV** (AllowLowerV | AllowUpperV): Allows both lowercase and uppercase 'v' prefixes.
- **IncludeAllPrerelease** (2): Includes prerelease versions in range checks.
- **OptionalMinorPatch** (96): Makes minor and patch versions optional.
- **OptionalPatch** (32): Makes the patch version optional.
- **Strict** (0): Strict parsing rules, no extra allowances.
```

--------------------------------

### SemVersionRangeOptions

Source: https://github.com/walkercoderanger/semver/blob/master/Semver/PublicAPI/net5.0/PublicAPI.Shipped.txt

Enumeration of options that can be used to configure SemVersionRange parsing.

```APIDOC
## SemVersionRangeOptions

### Description
Defines options for parsing and interpreting semantic version ranges.

### Options
- **AllowLeadingZeros** (1): Allows leading zeros in version components.
- **IncludeAllPrerelease** (2): Includes prerelease versions in range checks.
- **AllowMetadata** (4): Allows build metadata in version strings.
- **AllowTrailingWhitespace** (4): Allows trailing whitespace in version strings.
- **AllowLeadingWhitespace** (2): Allows leading whitespace in version strings.
- **AllowLowerV** (8): Allows the lowercase 'v' prefix.
- **AllowUpperV** (16): Allows the uppercase 'V' prefix.
- **OptionalMinorPatch** (96): Makes minor and patch versions optional.
- **OptionalPatch** (32): Makes the patch version optional.
- **Loose** (-1): A combination of options for a more lenient parsing.
- **Strict** (0): The default strict parsing options.
```

--------------------------------

### Semver.Comparers.ISemVersionComparer

Source: https://github.com/walkercoderanger/semver/blob/master/Semver/PublicAPI/net5.0/PublicAPI.Shipped.txt

Represents a comparer for semantic versions.

```APIDOC
## Semver.Comparers.ISemVersionComparer

### Description
Interface for comparing semantic versions.
```

--------------------------------

### SemVersionStyles

Source: https://github.com/walkercoderanger/semver/blob/master/Semver/PublicAPI/net5.0/PublicAPI.Shipped.txt

Enumeration of styles that can be used to configure SemVersion parsing.

```APIDOC
## SemVersionStyles

### Description
Defines styles that can be used to configure the parsing of semantic version strings.

### Styles
- **AllowLeadingZeros** (1): Allows leading zeros in version components.
- **AllowLeadingWhitespace** (2): Allows leading whitespace in version strings.
- **AllowTrailingWhitespace** (4): Allows trailing whitespace in version strings.
- **AllowLowerV** (8): Allows the lowercase 'v' prefix.
- **AllowUpperV** (16): Allows the uppercase 'V' prefix.
- **OptionalMinorPatch** (96): Makes minor and patch versions optional.
- **OptionalPatch** (32): Makes the patch version optional.
- **Strict** (0): The default strict parsing style.
- **AllowWhitespace** (-6): A combination of AllowLeadingWhitespace and AllowTrailingWhitespace.
- **AllowV** (-24): A combination of AllowLowerV and AllowUpperV.
- **Any** (-1): A combination of all available styles for the most permissive parsing.
```

--------------------------------

### SemVersion Comparison

Source: https://github.com/walkercoderanger/semver/blob/master/Semver/PublicAPI/netstandard2.0/PublicAPI.Shipped.txt

Methods for comparing Semver.SemVersion objects based on precedence and sort order.

```APIDOC
## SemVersion Comparison

### Description
Methods for comparing Semver.SemVersion objects.

### Methods

#### `Semver.SemVersion.ComparePrecedence(Semver.SemVersion? left, Semver.SemVersion? right)`
Compares two Semver.SemVersion objects based on precedence.

#### `Semver.SemVersion.CompareSortOrder(Semver.SemVersion? left, Semver.SemVersion? right)`
Compares two Semver.SemVersion objects based on sort order.

#### `Semver.SemVersion.PrecedenceEquals(Semver.SemVersion? left, Semver.SemVersion? right)`
Checks if two Semver.SemVersion objects are equal in precedence.

#### `Semver.SemVersion.Equals(Semver.SemVersion? left, Semver.SemVersion? right)`
Checks if two Semver.SemVersion objects are equal.

#### `Semver.SemVersion.operator ==(Semver.SemVersion? left, Semver.SemVersion? right)`
Equality operator for Semver.SemVersion.

#### `Semver.SemVersion.operator !=(Semver.SemVersion? left, Semver.SemVersion? right)`
Inequality operator for Semver.SemVersion.
```

--------------------------------

### Semver.SemVersionRange Parsing

Source: https://github.com/walkercoderanger/semver/blob/master/Semver/PublicAPI/netstandard2.1/PublicAPI.Shipped.txt

Methods for parsing version range strings into Semver.SemVersionRange objects.

```APIDOC
## Semver.SemVersionRange.Parse

### Description
Parses a version range string using specified options.

### Method
static

### Endpoint
N/A (static method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
Semver.SemVersionRange

#### Response Example
None
```

```APIDOC
## Semver.SemVersionRange.ParseNpm

### Description
Parses an NPM-style version range string.

### Method
static

### Endpoint
N/A (static method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
Semver.SemVersionRange

#### Response Example
None
```

```APIDOC
## Semver.SemVersionRange.TryParse

### Description
Attempts to parse a version range string into a Semver.SemVersionRange object.

### Method
static

### Endpoint
N/A (static method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
bool

#### Response Example
None
```

```APIDOC
## Semver.SemVersionRange.TryParseNpm

### Description
Attempts to parse an NPM-style version range string.

### Method
static

### Endpoint
N/A (static method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
bool

#### Response Example
None
```

--------------------------------

### SemVersionRangeOptions and SemVersionStyles

Source: https://github.com/walkercoderanger/semver/blob/master/Semver/PublicAPI/netstandard2.1/PublicAPI.Shipped.txt

Defines options and styles for parsing and interpreting semantic versions and ranges.

```APIDOC
## SemVersionRangeOptions and SemVersionStyles

### Description
These enumerations provide flags to control the parsing behavior and interpretation of semantic versions and version ranges, allowing for flexibility in handling different formats and requirements.

### SemVersionRangeOptions

**Description**: Options that control the behavior of `SemVersionRange` parsing and comparison.

**Values**:
- `AllowLeadingZeros` (1): Allows leading zeros in version components.
- `IncludeAllPrerelease` (2): Includes prerelease versions in range checks.
- `AllowMetadata` (4): Allows metadata in version comparisons.
- `AllowTrailingWhitespace` (8): Allows trailing whitespace.
- `AllowLowerV` (16): Allows a lowercase 'v' prefix.
- `AllowUpperV` (32): Allows an uppercase 'V' prefix.
- `OptionalPatch` (32): Makes the patch version optional.
- `OptionalMinorPatch` (96): Makes minor and patch versions optional.
- `Loose`: A combination of `AllowLeadingZeros`, `AllowMetadata`, `AllowV`, and `OptionalMinorPatch` for more lenient parsing.
- `Strict` (0): The default, strict parsing behavior.

### SemVersionStyles

**Description**: Styles that control the parsing of `SemVersion` strings.

**Values**:
- `AllowLeadingZeros` (1): Allows leading zeros in version components.
- `IncludeAllPrerelease` (2): Includes prerelease versions.
- `AllowTrailingWhitespace` (4): Allows trailing whitespace.
- `AllowLowerV` (8): Allows a lowercase 'v' prefix.
- `AllowUpperV` (16): Allows an uppercase 'V' prefix.
- `OptionalPatch` (32): Makes the patch version optional.
- `OptionalMinorPatch` (96): Makes minor and patch versions optional.
- `AllowWhitespace`: A combination of `AllowLeadingWhitespace` and `AllowTrailingWhitespace`.
- `AllowV`: A combination of `AllowLowerV` and `AllowUpperV`.
- `Any` (-1): Allows all styles.
- `Strict` (0): The default, strict parsing style.

```