diff --git a/BytecodeApi.Win32/Interop/KeyboardHookEventArgs.cs b/BytecodeApi.Win32/Interop/KeyboardHookEventArgs.cs
index 85e386c..ab49520 100644
--- a/BytecodeApi.Win32/Interop/KeyboardHookEventArgs.cs
+++ b/BytecodeApi.Win32/Interop/KeyboardHookEventArgs.cs
@@ -1,3 +1,4 @@
+using System.ComponentModel;
 using System.Windows.Forms;
 
 namespace BytecodeApi.Win32.Interop;
@@ -5,7 +6,7 @@ namespace BytecodeApi.Win32.Interop;
 /// <summary>
 /// Provides data for the <see cref="GlobalKeyboardHook.KeyPressed" /> event.
 /// </summary>
-public sealed class KeyboardHookEventArgs : EventArgs
+public sealed class KeyboardHookEventArgs : HandledEventArgs
 {
 	/// <summary>
 	/// Gets the keycode of the pressed key.
@@ -19,10 +20,6 @@ public sealed class KeyboardHookEventArgs : EventArgs
 	/// Gets the key character, or '\0', if the key does not represent a printable character.
 	/// </summary>
 	public char KeyChar { get; }
-	/// <summary>
-	/// Gets or sets a <see cref="bool" /> value indicating whether to cancel the keyboard event.
-	/// </summary>
-	public bool Handled { get; set; }
 
 	/// <summary>
 	/// Initializes a new instance of the <see cref="KeyboardHookEventArgs" /> class.
diff --git a/BytecodeApi/Data/Pagination.cs b/BytecodeApi/Data/Pagination.cs
new file mode 100644
index 0000000..6b0ee39
--- /dev/null
+++ b/BytecodeApi/Data/Pagination.cs
@@ -0,0 +1,51 @@
+namespace BytecodeApi.Data;
+
+/// <summary>
+/// Provides information about the pagination of a collection of items.
+/// </summary>
+public sealed class Pagination
+{
+	/// <summary>
+	/// Gets or sets the zero based page index.
+	/// The default value is 0.
+	/// </summary>
+	public int Page { get; set; }
+	/// <summary>
+	/// Gets or sets the number of items included in a page.
+	/// The default value is 10.
+	/// </summary>
+	public int PageSize { get; set; }
+	/// <summary>
+	/// Gets or sets the total number of items, or <see langword="null" />, if the total number of items is unknown.
+	/// </summary>
+	public int? TotalCount { get; set; }
+	/// <summary>
+	/// Gets the total number of pages, or <see langword="null" />, if the total number of items is unknown.
+	/// </summary>
+	public int? PageCount => TotalCount is null or < 0 || PageSize <= 0 ? null : (TotalCount.Value + PageSize - 1) / PageSize;
+	/// <summary>
+	/// Gets the number of items to skip in order to get the items for the current page.
+	/// </summary>
+	public int Skip => Page * PageSize;
+
+	/// <summary>
+	/// Initializes a new instance of the <see cref="Pagination" /> class.
+	/// </summary>
+	public Pagination()
+	{
+		PageSize = 10;
+	}
+	/// <summary>
+	/// Initializes a new instance of the <see cref="Pagination" /> class.
+	/// </summary>
+	/// <param name="page">The zero based page index.</param>
+	/// <param name="pageSize">The number of items included in a page.</param>
+	public Pagination(int page, int pageSize) : this()
+	{
+		Check.ArgumentOutOfRangeEx.GreaterEqual0(page);
+		Check.ArgumentOutOfRangeEx.Greater0(pageSize);
+
+		Page = page;
+		PageSize = pageSize;
+	}
+}
\ No newline at end of file
diff --git a/BytecodeApi/Extensions/DateOnlyExtensions.cs b/BytecodeApi/Extensions/DateOnlyExtensions.cs
index 2b76b08..32d6342 100644
--- a/BytecodeApi/Extensions/DateOnlyExtensions.cs
+++ b/BytecodeApi/Extensions/DateOnlyExtensions.cs
@@ -318,5 +318,16 @@ public DateTime ToDateTime()
 		{
 			return dateOnly.ToDateTime(default);
 		}
+		/// <summary>
+		/// Returns a <see cref="DateTime" /> from this <see cref="DateOnly" /> value.
+		/// </summary>
+		/// <param name="kind">The <see cref="DateTimeKind" /> to be used for creation of the <see cref="DateTime" /> object.</param>
+		/// <returns>
+		/// The converted <see cref="DateTime" /> value.
+		/// </returns>
+		public DateTime ToDateTime(DateTimeKind kind)
+		{
+			return dateOnly.ToDateTime(default, kind);
+		}
 	}
 }
\ No newline at end of file
diff --git a/BytecodeApi/Extensions/EnumerableExtensions.cs b/BytecodeApi/Extensions/EnumerableExtensions.cs
index e1c81eb..9d30ceb 100644
--- a/BytecodeApi/Extensions/EnumerableExtensions.cs
+++ b/BytecodeApi/Extensions/EnumerableExtensions.cs
@@ -1,4 +1,5 @@
 using System.Collections;
+using System.ComponentModel;
 
 namespace BytecodeApi.Extensions;
 
@@ -627,6 +628,118 @@ public static IEnumerable<TSource> Union<TSource>(this IEnumerable<TSource> firs
 		return first.Union([second], comparer);
 	}
 	/// <summary>
+	/// Sorts the elements of a sequence in ascending or descending order, depending on the specified <see cref="ListSortDirection" />.
+	/// </summary>
+	/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
+	/// <param name="source">A sequence of values to sort.</param>
+	/// <param name="direction">Specifies the direction to sort (ascending or descending).</param>
+	/// <returns>
+	/// An <see cref="IOrderedEnumerable{T}" /> whose elements are sorted according to the specified direction.
+	/// </returns>
+	public static IOrderedEnumerable<TSource> Order<TSource>(this IEnumerable<TSource> source, ListSortDirection direction)
+	{
+		return source.Order(direction, null);
+	}
+	/// <summary>
+	/// Sorts the elements of a sequence in ascending or descending order, depending on the specified <see cref="ListSortDirection" />.
+	/// </summary>
+	/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
+	/// <param name="source">A sequence of values to sort.</param>
+	/// <param name="direction">Specifies the direction to sort (ascending or descending).</param>
+	/// <param name="comparer">An <see cref="IComparer{T}" /> to compare the elements.</param>
+	/// <returns>
+	/// An <see cref="IOrderedEnumerable{T}" /> whose elements are sorted according to the specified direction.
+	/// </returns>
+	public static IOrderedEnumerable<TSource> Order<TSource>(this IEnumerable<TSource> source, ListSortDirection direction, IComparer<TSource>? comparer)
+	{
+		Check.ArgumentNull(source);
+
+		return direction switch
+		{
+			ListSortDirection.Ascending => source.Order(comparer),
+			ListSortDirection.Descending => source.OrderDescending(comparer),
+			_ => throw Throw.InvalidEnumArgument(nameof(direction), direction)
+		};
+	}
+	/// <summary>
+	/// Sorts the elements of a sequence in ascending or descending order, depending on the specified <see cref="ListSortDirection" />.
+	/// </summary>
+	/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
+	/// <typeparam name="TKey">The type of the key returned by <paramref name="keySelector" />.</typeparam>
+	/// <param name="source">A sequence of values to sort.</param>
+	/// <param name="keySelector">A function to extract a key from an element.</param>
+	/// <param name="direction">Specifies the direction to sort (ascending or descending).</param>
+	/// <returns>
+	/// An <see cref="IOrderedEnumerable{T}" /> whose elements are sorted according to the specified direction.
+	/// </returns>
+	public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, ListSortDirection direction)
+	{
+		return source.OrderBy(keySelector, direction, null);
+	}
+	/// <summary>
+	/// Sorts the elements of a sequence in ascending or descending order, depending on the specified <see cref="ListSortDirection" />.
+	/// </summary>
+	/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
+	/// <typeparam name="TKey">The type of the key returned by <paramref name="keySelector" />.</typeparam>
+	/// <param name="source">A sequence of values to sort.</param>
+	/// <param name="keySelector">A function to extract a key from an element.</param>
+	/// <param name="direction">Specifies the direction to sort (ascending or descending).</param>
+	/// <param name="comparer">An <see cref="IComparer{T}" /> to compare keys, or <see langword="null" /> to use the default comparer.</param>
+	/// <returns>
+	/// An <see cref="IOrderedEnumerable{T}" /> whose elements are sorted according to the specified direction.
+	/// </returns>
+	public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, ListSortDirection direction, IComparer<TKey>? comparer)
+	{
+		Check.ArgumentNull(source);
+		Check.ArgumentNull(keySelector);
+
+		return direction switch
+		{
+			ListSortDirection.Ascending => source.OrderBy(keySelector, comparer),
+			ListSortDirection.Descending => source.OrderByDescending(keySelector, comparer),
+			_ => throw Throw.InvalidEnumArgument(nameof(direction), direction)
+		};
+	}
+	/// <summary>
+	/// Performs a subsequent ordering of a sequence in ascending or descending order, depending on the specified <see cref="ListSortDirection" />.
+	/// </summary>
+	/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
+	/// <typeparam name="TKey">The type of the key returned by <paramref name="keySelector" />.</typeparam>
+	/// <param name="source">A sequence of values to sort.</param>
+	/// <param name="keySelector">A function to extract a key from an element.</param>
+	/// <param name="direction">Specifies the direction to sort (ascending or descending).</param>
+	/// <returns>
+	/// An <see cref="IOrderedEnumerable{T}" /> whose elements are sorted according to the specified direction.
+	/// </returns>
+	public static IOrderedEnumerable<TSource> ThenBy<TSource, TKey>(this IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector, ListSortDirection direction)
+	{
+		return source.ThenBy(keySelector, direction, null);
+	}
+	/// <summary>
+	/// Performs a subsequent ordering of a sequence in ascending or descending order, depending on the specified <see cref="ListSortDirection" />.
+	/// </summary>
+	/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
+	/// <typeparam name="TKey">The type of the key returned by <paramref name="keySelector" />.</typeparam>
+	/// <param name="source">A sequence of values to sort.</param>
+	/// <param name="keySelector">A function to extract a key from an element.</param>
+	/// <param name="direction">Specifies the direction to sort (ascending or descending).</param>
+	/// <param name="comparer">An <see cref="IComparer{T}" /> to compare keys, or <see langword="null" /> to use the default comparer.</param>
+	/// <returns>
+	/// An <see cref="IOrderedEnumerable{T}" /> whose elements are sorted according to the specified direction.
+	/// </returns>
+	public static IOrderedEnumerable<TSource> ThenBy<TSource, TKey>(this IOrderedEnumerable<TSource> source, Func<TSource, TKey> keySelector, ListSortDirection direction, IComparer<TKey>? comparer)
+	{
+		Check.ArgumentNull(source);
+		Check.ArgumentNull(keySelector);
+
+		return direction switch
+		{
+			ListSortDirection.Ascending => source.ThenBy(keySelector, comparer),
+			ListSortDirection.Descending => source.ThenByDescending(keySelector, comparer),
+			_ => throw Throw.InvalidEnumArgument(nameof(direction), direction)
+		};
+	}
+	/// <summary>
 	/// Randomizes the order of the elements of a sequence.
 	/// </summary>
 	/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
@@ -634,7 +747,7 @@ public static IEnumerable<TSource> Union<TSource>(this IEnumerable<TSource> firs
 	/// <returns>
 	/// An <see cref="IOrderedEnumerable{T}" /> whose elements are sorted in randomized order.
 	/// </returns>
-	public static IOrderedEnumerable<TSource> SortRandom<TSource>(this IEnumerable<TSource> source)
+	public static IOrderedEnumerable<TSource> OrderRandom<TSource>(this IEnumerable<TSource> source)
 	{
 		Check.ArgumentNull(source);
 
diff --git a/BytecodeApi/Extensions/QueryableExtensions.cs b/BytecodeApi/Extensions/QueryableExtensions.cs
new file mode 100644
index 0000000..f41465a
--- /dev/null
+++ b/BytecodeApi/Extensions/QueryableExtensions.cs
@@ -0,0 +1,57 @@
+using System.ComponentModel;
+using System.Linq.Expressions;
+
+namespace BytecodeApi.Extensions;
+
+/// <summary>
+/// Provides a set of <see langword="static" /> methods for interaction with <see cref="IQueryable{T}" /> objects.
+/// </summary>
+public static class QueryableExtensions
+{
+	/// <summary>
+	/// Sorts the elements of a sequence in ascending or descending order, depending on the specified <see cref="ListSortDirection" />.
+	/// </summary>
+	/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
+	/// <typeparam name="TKey">The type of the key returned by <paramref name="keySelector" />.</typeparam>
+	/// <param name="source">A sequence of values to sort.</param>
+	/// <param name="keySelector">A function to extract a key from an element.</param>
+	/// <param name="direction">Specifies the direction to sort (ascending or descending).</param>
+	/// <returns>
+	/// An <see cref="IOrderedQueryable{T}" /> whose elements are sorted according to the specified direction.
+	/// </returns>
+	public static IOrderedQueryable<TSource> OrderBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, ListSortDirection direction)
+	{
+		Check.ArgumentNull(source);
+		Check.ArgumentNull(keySelector);
+
+		return direction switch
+		{
+			ListSortDirection.Ascending => source.OrderBy(keySelector),
+			ListSortDirection.Descending => source.OrderByDescending(keySelector),
+			_ => throw Throw.InvalidEnumArgument(nameof(direction), direction)
+		};
+	}
+	/// <summary>
+	/// Performs a subsequent ordering of a sequence in ascending or descending order, depending on the specified <see cref="ListSortDirection" />.
+	/// </summary>
+	/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
+	/// <typeparam name="TKey">The type of the key returned by <paramref name="keySelector" />.</typeparam>
+	/// <param name="source">A sequence of values to sort.</param>
+	/// <param name="keySelector">A function to extract a key from an element.</param>
+	/// <param name="direction">Specifies the direction to sort (ascending or descending).</param>
+	/// <returns>
+	/// An <see cref="IOrderedQueryable{T}" /> whose elements are sorted according to the specified direction.
+	/// </returns>
+	public static IOrderedQueryable<TSource> ThenBy<TSource, TKey>(this IOrderedQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, ListSortDirection direction)
+	{
+		Check.ArgumentNull(source);
+		Check.ArgumentNull(keySelector);
+
+		return direction switch
+		{
+			ListSortDirection.Ascending => source.ThenBy(keySelector),
+			ListSortDirection.Descending => source.ThenByDescending(keySelector),
+			_ => throw Throw.InvalidEnumArgument(nameof(direction), direction)
+		};
+	}
+}
\ No newline at end of file
diff --git a/BytecodeApi/Extensions/VersionExtensions.cs b/BytecodeApi/Extensions/VersionExtensions.cs
new file mode 100644
index 0000000..c646dd9
--- /dev/null
+++ b/BytecodeApi/Extensions/VersionExtensions.cs
@@ -0,0 +1,47 @@
+namespace BytecodeApi.Extensions;
+
+/// <summary>
+/// Provides a set of <see langword="static" /> methods for interaction with <see cref="Version" /> objects.
+/// </summary>
+public static class VersionExtensions
+{
+	extension(Version version)
+	{
+		/// <summary>
+		/// Determines whether this instance is equal to another <see cref="Version" />.
+		/// </summary>
+		/// <param name="other">The <see cref="Version" /> to compare to this instance.</param>
+		/// <param name="fieldCount">The number of fields to compare.</param>
+		/// <returns>
+		/// <see langword="true" />, if this instance is equal to the <paramref name="other" /> parameter;
+		/// otherwise, <see langword="false" />.
+		/// </returns>
+		public bool Equals(Version other, int fieldCount)
+		{
+			Check.ArgumentOutOfRange(fieldCount is >= 0 and <= 4, nameof(fieldCount), "Field count must be between 0 and 4.");
+
+			return version.CompareTo(other, fieldCount) == 0;
+		}
+		/// <summary>
+		/// Compares this instance to a specified <see cref="Version" /> and returns a comparison of their relative values.
+		/// </summary>
+		/// <param name="other">A <see cref="Version" /> to compare with this instance.</param>
+		/// <param name="fieldCount">The number of fields to compare.</param>
+		/// <returns>
+		/// A value that indicates the relative order of the objects being compared.
+		/// </returns>
+		public int CompareTo(Version other, int fieldCount)
+		{
+			Check.ArgumentOutOfRange(fieldCount is >= 0 and <= 4, nameof(fieldCount), "Field count must be between 0 and 4.");
+
+			int result;
+
+			if (fieldCount >= 1 && (result = version.Major.CompareTo(other.Major)) != 0) return result;
+			if (fieldCount >= 2 && (result = version.Minor.CompareTo(other.Minor)) != 0) return result;
+			if (fieldCount >= 3 && (result = version.Build.CompareTo(other.Build)) != 0) return result;
+			if (fieldCount >= 4 && (result = version.Revision.CompareTo(other.Revision)) != 0) return result;
+
+			return 0;
+		}
+	}
+}
\ No newline at end of file
diff --git a/BytecodeApi/HandleableExceptionEventArgs.cs b/BytecodeApi/HandleableExceptionEventArgs.cs
new file mode 100644
index 0000000..a8f10ff
--- /dev/null
+++ b/BytecodeApi/HandleableExceptionEventArgs.cs
@@ -0,0 +1,25 @@
+using System.ComponentModel;
+
+namespace BytecodeApi;
+
+/// <summary>
+/// Provides data for events that are raised when an unhandled exception occurs that can be handled by user code.
+/// </summary>
+public sealed class HandleableExceptionEventArgs : HandledEventArgs
+{
+	/// <summary>
+	/// Gets the unhandled exception that was raised.
+	/// </summary>
+	public Exception Exception { get; }
+
+	/// <summary>
+	/// Initializes a new instance of the <see cref="HandleableExceptionEventArgs" /> class.
+	/// </summary>
+	/// <param name="exception">The unhandled exception that was raised.</param>
+	public HandleableExceptionEventArgs(Exception exception)
+	{
+		Check.ArgumentNull(exception);
+
+		Exception = exception;
+	}
+}
\ No newline at end of file
diff --git a/BytecodeApi/HandleableExceptionEventHandler.cs b/BytecodeApi/HandleableExceptionEventHandler.cs
new file mode 100644
index 0000000..ef18f34
--- /dev/null
+++ b/BytecodeApi/HandleableExceptionEventHandler.cs
@@ -0,0 +1,8 @@
+namespace BytecodeApi;
+
+/// <summary>
+/// Represents the method that is called when an unhandled exception occurs that can be handled by user code.
+/// </summary>
+/// <param name="sender">The object that raised the event.</param>
+/// <param name="e">A <see cref="HandleableExceptionEventArgs" /> that contains the event data.</param>
+public delegate void HandleableExceptionEventHandler(object sender, HandleableExceptionEventArgs e);
\ No newline at end of file