diff --git a/Ical.Net.Benchmarks/ApplicationWorkflows.cs b/Ical.Net.Benchmarks/ApplicationWorkflows.cs
index 92aa8b29e..3c068ea1f 100644
--- a/Ical.Net.Benchmarks/ApplicationWorkflows.cs
+++ b/Ical.Net.Benchmarks/ApplicationWorkflows.cs
@@ -5,6 +5,7 @@
 
 using BenchmarkDotNet.Attributes;
 using Ical.Net.DataTypes;
+using NodaTime;
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -14,8 +15,13 @@ namespace Ical.Net.Benchmarks;
 
 public class ApplicationWorkflows
 {
-    private static readonly CalDateTime _searchStart = CalDateTime.Now.AddDays(-365);
-    private static readonly CalDateTime _searchEnd = CalDateTime.Now;
+    private static DateTimeZone tz = DateTimeZoneProviders.Tzdb["America/New_York"];
+
+    private static readonly Instant _searchEnd = SystemClock.Instance.GetCurrentInstant();
+    private static readonly ZonedDateTime _searchStart = _searchEnd
+        .Minus(NodaTime.Duration.FromDays(365))
+        .InZone(tz);
+
     private static readonly List<string> _manyCalendars = GetIcalStrings();
 
     private static List<string> GetIcalStrings()
@@ -38,7 +44,7 @@ public List<Occurrence> SingleThreaded()
         return _manyCalendars
             .SelectMany(Calendar.Load<Calendar>)
             .SelectMany(c => c.Events)
-            .SelectMany(e => e.GetOccurrences(_searchStart).TakeWhile(p => p.Period.StartTime < _searchEnd))
+            .SelectMany(e => e.GetOccurrences(_searchStart).TakeWhile(p => p.Start.ToInstant() < _searchEnd))
             .ToList();
     }
 
@@ -49,7 +55,7 @@ public List<Occurrence> ParallelUponDeserialize()
             .AsParallel()
             .SelectMany(Calendar.Load<Calendar>)
             .SelectMany(c => c.Events)
-            .SelectMany(e => e.GetOccurrences(_searchStart).TakeWhile(p => p.Period.StartTime < _searchEnd))
+            .SelectMany(e => e.GetOccurrences(_searchStart).TakeWhile(p => p.Start.ToInstant() < _searchEnd))
             .ToList();
     }
 
@@ -60,7 +66,7 @@ public List<Occurrence> ParallelUponGetOccurrences()
             .SelectMany(Calendar.Load<Calendar>)
             .SelectMany(c => c.Events)
             .AsParallel()
-            .SelectMany(e => e.GetOccurrences(_searchStart).TakeWhile(p => p.Period.StartTime < _searchEnd))
+            .SelectMany(e => e.GetOccurrences(_searchStart).TakeWhile(p => p.Start.ToInstant() < _searchEnd))
             .ToList();
     }
 
@@ -72,7 +78,7 @@ public List<Occurrence> ParallelDeserializeSequentialGatherEventsParallelGetOccu
             .SelectMany(Calendar.Load<Calendar>)
             .AsSequential()
             .SelectMany(c => c.Events)
-            .SelectMany(e => e.GetOccurrences(_searchStart).TakeWhile(p => p.Period.StartTime < _searchEnd))
+            .SelectMany(e => e.GetOccurrences(_searchStart).TakeWhile(p => p.Start.ToInstant() < _searchEnd))
             .ToList();
     }
 }
diff --git a/Ical.Net.Benchmarks/OccurencePerfTests.cs b/Ical.Net.Benchmarks/OccurencePerfTests.cs
index a17ab58ce..ce38a0c89 100644
--- a/Ical.Net.Benchmarks/OccurencePerfTests.cs
+++ b/Ical.Net.Benchmarks/OccurencePerfTests.cs
@@ -6,6 +6,7 @@
 using BenchmarkDotNet.Attributes;
 using Ical.Net.CalendarComponents;
 using Ical.Net.DataTypes;
+using NodaTime;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -17,6 +18,8 @@ public class OccurencePerfTests
     private Calendar _calendarFourEvents = null!;
     private Calendar _calendarWithRecurrences = null!;
 
+    private static DateTimeZone tz = DateTimeZoneProviders.Tzdb["America/New_York"];
+
     [GlobalSetup]
     public void Setup()
     {
@@ -27,35 +30,69 @@ public void Setup()
     [Benchmark]
     public void GetOccurrences()
     {
-        _ = _calendarWithRecurrences.GetOccurrences().ToList();
+        _ = _calendarWithRecurrences.GetOccurrences(tz).ToList();
     }
 
     [Benchmark]
     public void MultipleEventsWithUntilOccurrencesSearchingByWholeCalendar()
     {
-        var searchStart = _calendarFourEvents.Events.First().DtStart!.AddYears(-1);
-        var searchEnd = _calendarFourEvents.Events.Last().DtStart!.AddYears(1);
-        _ = _calendarFourEvents.GetOccurrences(searchStart).TakeWhile(p => p.Period.StartTime < searchEnd);
+        var searchStart = _calendarFourEvents.Events.First().DtStart!
+            .ToZonedDateTime(tz)
+            .LocalDateTime
+            .PlusYears(-1)
+            .InZoneLeniently(tz);
+
+        var searchEnd = _calendarFourEvents.Events.Last().DtStart!
+            .ToZonedDateTime(tz)
+            .LocalDateTime
+            .PlusYears(1)
+            .InZoneLeniently(tz)
+            .ToInstant();
+
+        _ = _calendarFourEvents.GetOccurrences(searchStart).TakeWhile(p => p.Start.ToInstant() < searchEnd);
     }
 
     [Benchmark]
     public void MultipleEventsWithUntilOccurrences()
     {
-        var searchStart = _calendarFourEvents.Events.First().DtStart!.AddYears(-1);
-        var searchEnd = _calendarFourEvents.Events.Last().DtStart!.AddYears(1);
+        var searchStart = _calendarFourEvents.Events.First().DtStart!
+            .ToZonedDateTime(tz)
+            .LocalDateTime
+            .PlusYears(-1)
+            .InZoneLeniently(tz);
+
+        var searchEnd = _calendarFourEvents.Events.Last().DtStart!
+            .ToZonedDateTime(tz)
+            .LocalDateTime
+            .PlusYears(1)
+            .InZoneLeniently(tz)
+            .ToInstant();
+
         _ = _calendarFourEvents.Events
-            .SelectMany(e => e.GetOccurrences(searchStart).TakeWhile(p => p.Period.StartTime < searchEnd))
+            .SelectMany(e => e.GetOccurrences(searchStart).TakeWhile(p => p.Start.ToInstant() < searchEnd))
             .ToList();
     }
 
     [Benchmark]
     public void MultipleEventsWithUntilOccurrencesEventsAsParallel()
     {
-        var searchStart = _calendarFourEvents.Events.First().DtStart!.AddYears(-1);
-        var searchEnd = _calendarFourEvents.Events.Last().DtStart!.AddYears(1).AddDays(10);
+        var searchStart = _calendarFourEvents.Events.First().DtStart!
+            .ToZonedDateTime(tz)
+            .LocalDateTime
+            .PlusYears(-1)
+            .InZoneLeniently(tz);
+
+        var searchEnd = _calendarFourEvents.Events.Last().DtStart!
+            .ToZonedDateTime(tz)
+            .LocalDateTime
+            .PlusYears(1)
+            .PlusDays(10)
+            .InZoneLeniently(tz)
+            .ToInstant();
+
         _ = _calendarFourEvents.Events
             .AsParallel()
-            .SelectMany(e => e.GetOccurrences(searchStart).TakeWhile(p => p.Period.StartTime < searchEnd))
+            .SelectMany(e => e.GetOccurrences(searchStart).TakeWhile(p => p.Start.ToInstant() < searchEnd))
             .ToList();
     }
 
@@ -89,7 +126,7 @@ private static Calendar GetFourCalendarEventsWithUntilRule()
             {
                 var rrule = new RecurrencePattern(FrequencyType.Daily, 1)
                 {
-                    Until = new CalDateTime(startTime.AddDays(10)),
+                    Until = startTime.AddDays(10),
                 };
 
                 var e = new CalendarEvent
@@ -98,7 +135,7 @@ private static Calendar GetFourCalendarEventsWithUntilRule()
                     End = startTime.AddMinutes(10).ToTimeZone(tzid),
                     RecurrenceRules = new List<RecurrencePattern> { rrule },
                 };
-                startTime = startTime.Add(Duration.FromTimeSpanExact(interval));
+                startTime = startTime.Add(DataTypes.Duration.FromTimeSpanExact(interval));
                 return e;
             });
 
@@ -111,19 +148,41 @@ private static Calendar GetFourCalendarEventsWithUntilRule()
     public void MultipleEventsWithCountOccurrencesSearchingByWholeCalendar()
     {
         var calendar = GetFourCalendarEventsWithCountRule();
-        var searchStart = calendar.Events.First().DtStart!.AddYears(-1);
-        var searchEnd = calendar.Events.Last().DtStart!.AddYears(1);
-        _ = calendar.GetOccurrences(searchStart).TakeWhile(p => p.Period.StartTime < searchEnd);
+        var searchStart = _calendarFourEvents.Events.First().DtStart!
+            .ToZonedDateTime(tz)
+            .LocalDateTime
+            .PlusYears(-1)
+            .InZoneLeniently(tz);
+
+        var searchEnd = _calendarFourEvents.Events.Last().DtStart!
+            .ToZonedDateTime(tz)
+            .LocalDateTime
+            .PlusYears(1)
+            .InZoneLeniently(tz)
+            .ToInstant();
+
+        _ = calendar.GetOccurrences(searchStart).TakeWhile(p => p.Start.ToInstant() < searchEnd);
     }
 
     [Benchmark]
     public void MultipleEventsWithCountOccurrences()
     {
         var calendar = GetFourCalendarEventsWithCountRule();
-        var searchStart = calendar.Events.First().DtStart!.AddYears(-1);
-        var searchEnd = calendar.Events.Last().DtStart!.AddYears(1);
+        var searchStart = _calendarFourEvents.Events.First().DtStart!
+             .ToZonedDateTime(tz)
+             .LocalDateTime
+             .PlusYears(-1)
+             .InZoneLeniently(tz);
+
+        var searchEnd = _calendarFourEvents.Events.Last().DtStart!
+            .ToZonedDateTime(tz)
+            .LocalDateTime
+            .PlusYears(1)
+            .InZoneLeniently(tz)
+            .ToInstant();
+
         _ = calendar.Events
-            .SelectMany(e => e.GetOccurrences(searchStart).TakeWhile(p => p.Period.StartTime < searchEnd))
+            .SelectMany(e => e.GetOccurrences(searchStart).TakeWhile(p => p.Start.ToInstant() < searchEnd))
             .ToList();
     }
 
@@ -131,11 +190,23 @@ public void MultipleEventsWithCountOccurrences()
     public void MultipleEventsWithCountOccurrencesEventsAsParallel()
     {
         var calendar = GetFourCalendarEventsWithCountRule();
-        var searchStart = calendar.Events.First().DtStart!.AddYears(-1);
-        var searchEnd = calendar.Events.Last().DtStart!.AddYears(1).AddDays(10);
+        var searchStart = _calendarFourEvents.Events.First().DtStart!
+            .ToZonedDateTime(tz)
+            .LocalDateTime
+            .PlusYears(-1)
+            .InZoneLeniently(tz);
+
+        var searchEnd = _calendarFourEvents.Events.Last().DtStart!
+            .ToZonedDateTime(tz)
+            .LocalDateTime
+            .PlusYears(1)
+            .PlusDays(10)
+            .InZoneLeniently(tz)
+            .ToInstant();
+
         _ = calendar.Events
             .AsParallel()
-            .SelectMany(e => e.GetOccurrences(searchStart).TakeWhile(p => p.Period.StartTime < searchEnd))
+            .SelectMany(e => e.GetOccurrences(searchStart).TakeWhile(p => p.Start.ToInstant() < searchEnd))
             .ToList();
     }
 
diff --git a/Ical.Net.Benchmarks/ThroughputTests.cs b/Ical.Net.Benchmarks/ThroughputTests.cs
index 323676e4e..b3160e408 100644
--- a/Ical.Net.Benchmarks/ThroughputTests.cs
+++ b/Ical.Net.Benchmarks/ThroughputTests.cs
@@ -6,11 +6,14 @@
 using BenchmarkDotNet.Attributes;
 using System.Linq;
 using Ical.Net.DataTypes;
+using NodaTime;
 
 namespace Ical.Net.Benchmarks;
 
 public class ThroughputTests
 {
+    private static DateTimeZone tz = DateTimeZoneProviders.Tzdb["America/New_York"];
+
     [Benchmark]
     public void DeserializeAndComputeUntilOccurrences()
     {
@@ -68,9 +71,12 @@ rsion 08.00.0681.000"">\n<TITLE></TITLE>\n</HEAD>\n<BODY>\n<!-- Converted f
 
         var calendar = Calendar.Load(e)!;
         var calendarEvent = calendar.Events.First();
-        var searchStart = new CalDateTime(2009, 06, 20);
-        var searchEnd = new CalDateTime(2011, 06, 23);
-        var occurrences = calendarEvent.GetOccurrences(searchStart).TakeWhile(p => p.Period.StartTime < searchEnd);
+        var searchStart = tz.AtStartOfDay(new(2009, 06, 20));
+        var searchEnd = tz.AtStartOfDay(new(2011, 06, 23)).ToInstant();
+        var _ = calendarEvent
+            .GetOccurrences(searchStart)
+            .TakeWhile(p => p.Start.ToInstant() < searchEnd)
+            .ToList();
     }
 
     [Benchmark]
@@ -130,8 +136,11 @@ rsion 08.00.0681.000"">\n<TITLE></TITLE>\n</HEAD>\n<BODY>\n<!-- Converted f
 
         var calendar = Calendar.Load(e)!;
         var calendarEvent = calendar.Events.First();
-        var searchStart = new CalDateTime(2009, 06, 20);
-        var searchEnd = new CalDateTime(2011, 06, 23);
-        var occurrences = calendarEvent.GetOccurrences(searchStart).TakeWhile(p => p.Period.StartTime < searchEnd);
+        var searchStart = tz.AtStartOfDay(new(2009, 06, 20));
+        var searchEnd = tz.AtStartOfDay(new(2011, 06, 23)).ToInstant();
+        var _ = calendarEvent
+            .GetOccurrences(searchStart)
+            .TakeWhile(p => p.Start.ToInstant() < searchEnd)
+            .ToList();
     }
 }
diff --git a/Ical.Net.Tests/CalDateTimeTests.cs b/Ical.Net.Tests/CalDateTimeTests.cs
index 2ae019098..a9c9c5500 100644
--- a/Ical.Net.Tests/CalDateTimeTests.cs
+++ b/Ical.Net.Tests/CalDateTimeTests.cs
@@ -56,10 +56,10 @@ public void ToTimeZoneFloating()
     [Test, TestCaseSource(nameof(ToTimeZoneTestCases))]
     public void ToTimeZoneTests(CalendarEvent calendarEvent, string targetTimeZone)
     {
-        var startAsUtc = calendarEvent.Start!.AsUtc;
+        var startAsUtc = calendarEvent.Start!.ToInstant();
 
         var convertedStart = calendarEvent.Start.ToTimeZone(targetTimeZone);
-        var convertedAsUtc = convertedStart.AsUtc;
+        var convertedAsUtc = convertedStart.ToInstant();
 
         Assert.That(convertedAsUtc, Is.EqualTo(startAsUtc));
     }
@@ -97,11 +97,11 @@ public void SameDateTimeWithDifferentTzIdShouldReturnSameUtc()
         var someTime = DateTimeOffset.Parse("2018-05-21T11:35:00-04:00", CultureInfo.InvariantCulture);
 
         var someDt = new CalDateTime(someTime.DateTime, "America/New_York");
-        var firstUtc = someDt.AsUtc;
-        Assert.That(firstUtc, Is.EqualTo(someTime.UtcDateTime));
+        var firstUtc = someDt.ToInstant();
+        Assert.That(firstUtc, Is.EqualTo(NodaTime.Instant.FromDateTimeOffset(someTime)));
 
         someDt = new CalDateTime(someTime.DateTime, "Europe/Berlin");
-        var berlinUtc = someDt.AsUtc;
+        var berlinUtc = someDt.ToInstant();
         Assert.That(berlinUtc, Is.Not.EqualTo(firstUtc));
     }
 
@@ -150,7 +150,7 @@ public string ToStringTests(CalDateTime calDateTime, string format, IFormatProvi
     public static IEnumerable ToStringTestCases()
     {
         yield return new TestCaseData(new CalDateTime(2024, 8, 30, 10, 30, 0, tzId: "Pacific/Auckland"), "O", null)
-            .Returns("2024-08-30T10:30:00.0000000+12:00 Pacific/Auckland")
+            .Returns("2024-08-30T10:30:00.0000000 Pacific/Auckland")
             .SetName("Date and time with 'O' format arg, default culture");
 
         yield return new TestCaseData(new CalDateTime(2024, 8, 30), "O", null)
@@ -159,7 +159,7 @@ public static IEnumerable ToStringTestCases()
 
         yield return new TestCaseData(new CalDateTime(2024, 8, 30, 10, 30, 0, tzId: "Pacific/Auckland"), "O",
                 CultureInfo.GetCultureInfo("fr-FR"))
-            .Returns("2024-08-30T10:30:00.0000000+12:00 Pacific/Auckland")
+            .Returns("2024-08-30T10:30:00.0000000 Pacific/Auckland")
             .SetName("Date and time with 'O' format arg, French culture");
 
         yield return new TestCaseData(new CalDateTime(2024, 8, 30, 10, 30, 0, tzId: "Pacific/Auckland"),
@@ -306,8 +306,8 @@ public void Simple_PropertyAndMethod_HasTime_Tests()
         var c = new CalDateTime(dt, tzId: "Europe/Berlin");
 
         var c2 = new CalDateTime(dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, dt.Second, c.TzId);
-        var c3 = new CalDateTime(new DateOnly(dt.Year, dt.Month, dt.Day),
-            new TimeOnly(dt.Hour, dt.Minute, dt.Second), c.TzId);
+        var c3 = new CalDateTime(new NodaTime.LocalDate(dt.Year, dt.Month, dt.Day),
+            new NodaTime.LocalTime(dt.Hour, dt.Minute, dt.Second), c.TzId);
 
         Assert.Multiple(() =>
         {
@@ -316,41 +316,9 @@ public void Simple_PropertyAndMethod_HasTime_Tests()
             Assert.That(CalDateTime.UtcNow.Value.Kind, Is.EqualTo(DateTimeKind.Unspecified));
             Assert.That(CalDateTime.Today.Value.Kind, Is.EqualTo(DateTimeKind.Unspecified));
             Assert.That(c.DayOfYear, Is.EqualTo(dt.DayOfYear));
-            Assert.That(c.Time?.ToTimeSpan(), Is.EqualTo(dt.TimeOfDay));
+            Assert.That(c.Time, Is.EqualTo(NodaTime.LocalDateTime.FromDateTime(dt).TimeOfDay));
             Assert.That(c.Add(-Duration.FromSeconds(dt.Second)).Value.Second, Is.EqualTo(0));
             Assert.That(c.ToString("dd.MM.yyyy", CultureInfo.InvariantCulture), Is.EqualTo("02.01.2025 Europe/Berlin"));
-            // Create a date-only CalDateTime from a CalDateTime
-            Assert.That(new CalDateTime(new CalDateTime(2025, 1, 1)), Is.EqualTo(new CalDateTime(2025, 1, 1)));
-        });
-    }
-
-    private static TestCaseData[] AddAndSubtractTestCases => [
-        new TestCaseData(new CalDateTime(2024, 10, 27, 0, 0, 0, tzId: null), 0),
-        new TestCaseData(new CalDateTime(2024, 10, 27, 0, 0, 0, tzId: CalDateTime.UtcTzId), 0),
-        new TestCaseData(new CalDateTime(2024, 10, 27, 0, 0, 0, tzId: "Europe/Paris"), 1)
-        ];
-
-    [Test, TestCaseSource(nameof(AddAndSubtractTestCases))]
-    public void AddAndSubtract_ShouldBeReversible(CalDateTime t, int tzOffs)
-    {
-        var d = Duration.FromHours(4);
-        var expectedTimeSpan = d.ToTimeSpanUnspecified();
-
-        Assert.Multiple(() =>
-        {
-            Assert.That(t.Add(d).Add(-d), Is.EqualTo(t));
-            Assert.That(t.Add(d).SubtractExact(t), Is.EqualTo(expectedTimeSpan));
-            Assert.That(t.Add(d).SubtractExact(t), Is.EqualTo(d.ToTimeSpan(t)));
-        });
-
-        d = Duration.FromDays(1);
-        expectedTimeSpan = d.ToTimeSpanUnspecified().Add(TimeSpan.FromHours(tzOffs));
-
-        Assert.Multiple(() =>
-        {
-            Assert.That(t.Add(d).Add(-d), Is.EqualTo(t));
-            Assert.That(t.Add(d).SubtractExact(t), Is.EqualTo(expectedTimeSpan));
-            Assert.That(t.Add(d).SubtractExact(t), Is.EqualTo(d.ToTimeSpan(t)));
         });
     }
 
diff --git a/Ical.Net.Tests/CalendarEventTest.cs b/Ical.Net.Tests/CalendarEventTest.cs
index 1076005bc..38a8bbc6a 100644
--- a/Ical.Net.Tests/CalendarEventTest.cs
+++ b/Ical.Net.Tests/CalendarEventTest.cs
@@ -257,87 +257,6 @@ public void HourMinuteSecondOffsetParsingTest()
         Assert.That(negativeOffset?.Offset, Is.EqualTo(expectedNegative));
     }
 
-
-    [Test, Category("CalendarEvent")]
-    public void GetEffectiveDurationTests()
-    {
-        var dt = new DateTime(2025, 3, 1, 14, 30, 0);
-        const string tzIdStart = "America/New_York";
-        const string tzIdEnd = "Europe/London";
-
-        var evt = new CalendarEvent
-        {
-            DtStart = new CalDateTime(DateOnly.FromDateTime(dt), TimeOnly.FromDateTime(dt), tzIdStart),
-            DtEnd = new CalDateTime(DateOnly.FromDateTime(dt.AddHours(1)), TimeOnly.FromDateTime(dt.AddHours(1)), tzIdEnd)
-        };
-
-        var ed = evt.EffectiveDuration;
-        Assert.Multiple(() =>
-        {
-            Assert.That(evt.DtStart.Value, Is.EqualTo(dt));
-            Assert.That(evt.DtEnd.Value, Is.EqualTo(dt.AddHours(1)));
-            Assert.That(evt.EffectiveDuration, Is.EqualTo(Duration.FromHours(-4)));
-        });
-
-        evt = new CalendarEvent
-        {
-            DtStart = new CalDateTime(DateOnly.FromDateTime(dt.Date)),
-            DtEnd = new CalDateTime(DateOnly.FromDateTime(dt.Date))
-        };
-
-        Assert.Multiple(() =>
-        {
-            Assert.That(evt.DtStart.Value, Is.EqualTo(dt.Date));
-            Assert.That(evt.EffectiveDuration.IsZero, Is.True);
-        });
-
-        evt = new CalendarEvent
-        {
-            DtStart = new CalDateTime(DateOnly.FromDateTime(dt)),
-        };
-
-        Assert.Multiple(() =>
-        {
-            Assert.That(evt.DtStart.Value, Is.EqualTo(dt.Date));
-            Assert.That(evt.Duration, Is.Null);
-            Assert.That(evt.EffectiveDuration, Is.EqualTo(DataTypes.Duration.FromDays(1)));
-        });
-
-        evt = new CalendarEvent
-        {
-            DtStart = new CalDateTime(DateOnly.FromDateTime(dt), TimeOnly.FromDateTime(dt)),
-            Duration = Duration.FromHours(2),
-        };
-
-        Assert.Multiple(() => {
-            Assert.That(evt.DtStart.Value, Is.EqualTo(dt));
-            Assert.That(evt.DtEnd, Is.Null);
-            Assert.That(evt.EffectiveDuration, Is.EqualTo(Duration.FromHours(2)));
-        });
-
-        evt = new CalendarEvent()
-        {
-            DtStart = new CalDateTime(DateOnly.FromDateTime(dt.Date), TimeOnly.FromDateTime(dt.Date)),
-            Duration = Duration.FromHours(2),
-        };
-
-        Assert.Multiple(() => {
-            Assert.That(evt.DtStart.Value, Is.EqualTo(dt.Date));
-            Assert.That(evt.EffectiveDuration, Is.EqualTo(Duration.FromHours(2)));
-        });
-
-        evt = new CalendarEvent()
-        {
-            DtStart = new CalDateTime(DateOnly.FromDateTime(dt)),
-            Duration = Duration.FromDays(1),
-        };
-
-        Assert.Multiple(() => {
-            Assert.That(evt.DtStart.Value, Is.EqualTo(dt.Date));
-            Assert.That(evt.EffectiveDuration, Is.EqualTo(Duration.FromDays(1)));
-        });
-    }
-
     [Test]
     public void EitherEndTime_OrDuraction_CanBeSet()
     {
diff --git a/Ical.Net.Tests/DeserializationTests.cs b/Ical.Net.Tests/DeserializationTests.cs
index 5a4a03ac4..b9051cb1f 100644
--- a/Ical.Net.Tests/DeserializationTests.cs
+++ b/Ical.Net.Tests/DeserializationTests.cs
@@ -13,6 +13,7 @@
 using Ical.Net.DataTypes;
 using Ical.Net.Serialization;
 using Ical.Net.Serialization.DataTypes;
+using NodaTime;
 using NUnit.Framework;
 
 namespace Ical.Net.Tests;
@@ -123,13 +124,14 @@ public void Bug2938007()
             Assert.That(evt.End.HasTime, Is.EqualTo(true));
         });
 
-        foreach (var o in evt.GetOccurrences(new CalDateTime(2010, 1, 17, 0, 0, 0)).TakeWhileBefore(new CalDateTime(2010, 2, 1, 0, 0, 0)))
+        var results = evt.GetOccurrences(new LocalDateTime(2010, 1, 17, 0, 0, 0).InZoneLeniently("Asia/Tokyo"))
+            .TakeWhileBefore(new LocalDateTime(2010, 2, 1, 0, 0, 0).InZoneLeniently("Asia/Tokyo").ToInstant());
+
+        foreach (var o in results)
         {
             Assert.Multiple(() =>
             {
-                Assert.That(o.Period.StartTime.HasTime, Is.EqualTo(true));
-                Assert.That(o.Period.EndTime, Is.Null);
-                Assert.That(o.Period.EffectiveEndTime, Is.Not.Null);
+                Assert.That(o.Start.ToInstant(), Is.LessThan(o.End.ToInstant()));
             });
         }
     }
@@ -326,22 +328,25 @@ public void Google1()
         var iCal = Calendar.Load(IcsFiles.Google1);
         var evt = iCal.Events["594oeajmftl3r9qlkb476rpr3c@google.com"];
         Assert.That(evt, Is.Not.Null);
+        var dtStart2 = new CalDateTime(2006, 12, 18);
+        var dtStart3 = new CalDateTime(2006, 12, 18, 6,6,3);
+        var dtStart4 = new CalDateTime(2006, 12, 18, 6,6,3, "US-Eastern");
 
-        CalDateTime dtStart = new CalDateTime(2006, 12, 18);
-        CalDateTime dtEnd = new CalDateTime(2006, 12, 23);
-        var occurrences = iCal.GetOccurrences(dtStart).TakeWhileBefore(dtEnd).ToList();
+        var dtStart = new CalDateTime(2006, 12, 18).ToZonedDateTime(tzId);
+        var dtEnd = new CalDateTime(2006, 12, 23).ToZonedDateTime(tzId);
+        var occurrences = iCal.GetOccurrences(dtStart).TakeWhileBefore(dtEnd.ToInstant()).ToList();
 
         var dateTimes = new[]
         {
-            new CalDateTime(2006, 12, 18, 7, 0, 0, tzId),
-            new CalDateTime(2006, 12, 19, 7, 0, 0, tzId),
-            new CalDateTime(2006, 12, 20, 7, 0, 0, tzId),
-            new CalDateTime(2006, 12, 21, 7, 0, 0, tzId),
-            new CalDateTime(2006, 12, 22, 7, 0, 0, tzId)
+            new CalDateTime(2006, 12, 18, 7, 0, 0, tzId).ToZonedDateTime(tzId),
+            new CalDateTime(2006, 12, 19, 7, 0, 0, tzId).ToZonedDateTime(tzId),
+            new CalDateTime(2006, 12, 20, 7, 0, 0, tzId).ToZonedDateTime(tzId),
+            new CalDateTime(2006, 12, 21, 7, 0, 0, tzId).ToZonedDateTime(tzId),
+            new CalDateTime(2006, 12, 22, 7, 0, 0, tzId).ToZonedDateTime(tzId)
         };
 
         for (var i = 0; i < dateTimes.Length; i++)
-            Assert.That(occurrences[i].Period.StartTime, Is.EqualTo(dateTimes[i]), "Event should occur at " + dateTimes[i]);
+            Assert.That(occurrences[i].Start, Is.EqualTo(dateTimes[i]), "Event should occur at " + dateTimes[i]);
 
         Assert.That(occurrences, Has.Count.EqualTo(dateTimes.Length), "There should be exactly " + dateTimes.Length + " occurrences; there were " + occurrences.Count);
     }
@@ -392,7 +397,7 @@ public void RecurrenceDates1()
                     Is.EqualTo(date), "Should contain " + date);
             }
 
-            Assert.That(iCal.Events[0].RecurrenceDates.Contains(new Period(expectedStartTimes[1], expectedEndTime)));
+            Assert.That(iCal.Events[0].RecurrenceDates.Contains(new DataTypes.Period(expectedStartTimes[1], expectedEndTime)));
         });
     }
 
@@ -496,7 +501,7 @@ public void Language4()
     public void Outlook2007_LineFolds1()
     {
         var iCal = Calendar.Load(IcsFiles.Outlook2007LineFolds);
-        var events = iCal.GetOccurrences(new CalDateTime(2009, 06, 20)).TakeWhileBefore(new CalDateTime(2009, 06, 22)).ToList();
+        var events = iCal.GetOccurrences(new CalDateTime(2009, 06, 20).ToZonedDateTime("America/New_York")).TakeWhileBefore(new CalDateTime(2009, 06, 22).ToZonedDateTime("America/New_York").ToInstant()).ToList();
         Assert.That(events, Has.Count.EqualTo(1));
     }
 
@@ -505,7 +510,7 @@ public void Outlook2007_LineFolds2()
     {
         var longName = "The Exceptionally Long Named Meeting Room Whose Name Wraps Over Several Lines When Exported From Leading Calendar and Office Software Application Microsoft Office 2007";
         var iCal = Calendar.Load(IcsFiles.Outlook2007LineFolds);
-        var events = iCal.GetOccurrences<CalendarEvent>(new CalDateTime(2009, 06, 20)).TakeWhileBefore(new CalDateTime(2009, 06, 22)).ToList();
+        var events = iCal.GetOccurrences<CalendarEvent>(new CalDateTime(2009, 06, 20).ToZonedDateTime("America/New_York")).TakeWhileBefore(new CalDateTime(2009, 06, 22).ToZonedDateTime("America/New_York").ToInstant()).ToList();
         Assert.That(((CalendarEvent)events[0].Source).Location, Is.EqualTo(longName));
     }
 
@@ -640,7 +645,7 @@ public void CalendarWithMissingProdIdOrVersion_ShouldLeavePropertiesInvalid()
     public void DurationSerializer_ShouldReturn_ExpectedDuration(string text, int? weeks = null, int? days = null, int? hours = null, int? minutes = null, int? seconds = null)
     {
         var s = new DurationSerializer();
-        Assert.That((Duration?) s.Deserialize(new StringReader(text)), Is.EqualTo(new Duration(weeks, days, hours, minutes, seconds)));
+        Assert.That((DataTypes.Duration?) s.Deserialize(new StringReader(text)), Is.EqualTo(new DataTypes.Duration(weeks, days, hours, minutes, seconds)));
     }
 
     [Test, Category("DurationSerializer")]
@@ -651,7 +656,7 @@ public void Duration_InvalidArguments_ShouldThrow(string text)
         Assert.Multiple(() =>
         {
             Assert.That(new DurationSerializer().Deserialize(new StringReader(text)), Is.Null);
-            Assert.That(Duration.Parse(text), Is.Null);
+            Assert.That(DataTypes.Duration.Parse(text), Is.Null);
         });
     }
 }
diff --git a/Ical.Net.Tests/DocumentationExamples.cs b/Ical.Net.Tests/DocumentationExamples.cs
index cb2e350dc..40dac1186 100644
--- a/Ical.Net.Tests/DocumentationExamples.cs
+++ b/Ical.Net.Tests/DocumentationExamples.cs
@@ -9,6 +9,7 @@
 using System.Linq;
 using Ical.Net.CalendarComponents;
 using Ical.Net.DataTypes;
+using NodaTime.Extensions;
 using NUnit.Framework;
 
 namespace Ical.Net.Tests;
@@ -39,8 +40,8 @@ public void Daily_Test()
 
         // Count the occurrences between July 20, and Aug 5 -- there should be 12:
         // July 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
-        var searchStart = new CalDateTime(2016, 07, 20);
-        var searchEnd = new CalDateTime(2016, 08, 05);
+        var searchStart = new CalDateTime(2016, 07, 20).ToZonedDateTime("America/New_York");
+        var searchEnd = new CalDateTime(2016, 08, 05).ToZonedDateTime("America/New_York").ToInstant();
         var occurrences = calendar.GetOccurrences(searchStart).TakeWhileBefore(searchEnd).ToList();
         Assert.That(occurrences, Has.Count.EqualTo(12));
     }
@@ -64,8 +65,8 @@ public void EveryOtherTuesdayUntilTheEndOfTheYear_Test()
 
         // Count every other Tuesday between July 1 and Dec 31.
         // The first Tuesday is July 5. There should be 13 in total
-        var searchStart = new CalDateTime(2010, 01, 01);
-        var searchEnd = new CalDateTime(2016, 12, 31);
+        var searchStart = new CalDateTime(2010, 01, 01).ToZonedDateTime("America/New_York");
+        var searchEnd = new CalDateTime(2016, 12, 31).ToZonedDateTime("America/New_York").ToInstant();
         var tuesdays = vEvent.GetOccurrences(searchStart).TakeWhileBefore(searchEnd).ToList();
 
         Assert.That(tuesdays, Has.Count.EqualTo(13));
@@ -92,14 +93,14 @@ public void FourthThursdayOfNovember_Tests()
         };
         vEvent.RecurrenceRules = new List<RecurrencePattern> { rrule };
 
-        var searchStart = new CalDateTime(2000, 01, 01);
-        var searchEnd = new CalDateTime(2017, 01, 01);
+        var searchStart = new CalDateTime(2000, 01, 01).ToZonedDateTime("America/New_York");
+        var searchEnd = new CalDateTime(2017, 01, 01).ToZonedDateTime("America/New_York").ToInstant();
         var usThanksgivings = vEvent.GetOccurrences(searchStart).TakeWhileBefore(searchEnd).ToList();
 
         Assert.That(usThanksgivings, Has.Count.EqualTo(17));
         foreach (var thanksgiving in usThanksgivings)
         {
-            Assert.That(thanksgiving.Period.StartTime.DayOfWeek == DayOfWeek.Thursday, Is.True);
+            Assert.That(thanksgiving.Start.DayOfWeek == DayOfWeek.Thursday.ToIsoDayOfWeek(), Is.True);
         }
     }
 
@@ -125,8 +126,8 @@ public void DailyExceptSunday_Test()
         calendar.Events.Add(vEvent);
 
         // We are essentially counting all the days that aren't Sunday in 2016, so there should be 314
-        var searchStart = new CalDateTime(2015, 12, 31);
-        var searchEnd = new CalDateTime(2017, 01, 01);
+        var searchStart = new CalDateTime(2015, 12, 31).ToZonedDateTime("America/New_York");
+        var searchEnd = new CalDateTime(2017, 01, 01).ToZonedDateTime("America/New_York").ToInstant();
         var occurrences = calendar.GetOccurrences(searchStart).TakeWhileBefore(searchEnd).ToList();
         Assert.That(occurrences, Has.Count.EqualTo(314));
     }
diff --git a/Ical.Net.Tests/EqualityAndHashingTests.cs b/Ical.Net.Tests/EqualityAndHashingTests.cs
index 99f5971c3..d1b9f27b1 100644
--- a/Ical.Net.Tests/EqualityAndHashingTests.cs
+++ b/Ical.Net.Tests/EqualityAndHashingTests.cs
@@ -203,9 +203,5 @@ public void CalDateTimeComparisonOperatorTests()
     {
         TestComparison((dt1, dt2) => dt1 == dt2, (i1, i2) => i1 == i2);
         TestComparison((dt1, dt2) => dt1 != dt2, (i1, i2) => i1 != i2);
-        TestComparison((dt1, dt2) => dt1 > dt2, (i1, i2) => i1 > i2);
-        TestComparison((dt1, dt2) => dt1 >= dt2, (i1, i2) => i1 >= i2);
-        TestComparison((dt1, dt2) => dt1 < dt2, (i1, i2) => i1 < i2);
-        TestComparison((dt1, dt2) => dt1 <= dt2, (i1, i2) => i1 <= i2);
     }
 }
diff --git a/Ical.Net.Tests/FreeBusyTest.cs b/Ical.Net.Tests/FreeBusyTest.cs
index 22462ed9d..bda14fa85 100644
--- a/Ical.Net.Tests/FreeBusyTest.cs
+++ b/Ical.Net.Tests/FreeBusyTest.cs
@@ -4,8 +4,11 @@
 //
 
 #nullable enable
+using System;
+using System.Collections.Generic;
 using Ical.Net.CalendarComponents;
 using Ical.Net.DataTypes;
+using Ical.Net.Utility;
 using NUnit.Framework;
 
 namespace Ical.Net.Tests;
@@ -27,18 +30,19 @@ public void GetFreeBusyStatusByDateTime()
         evt.End = new CalDateTime(2025, 10, 1, 9, 0, 0);
 
         var freeBusy = cal.GetFreeBusy(
+            DateUtil.GetZone("America/New_York"),
             new CalDateTime(2025, 10, 1, 0, 0, 0),
             new CalDateTime(2025, 10, 7, 11, 59, 59))!;
 
         Assert.Multiple(() =>
         {
-            Assert.That(freeBusy.GetFreeBusyStatus(new CalDateTime(2025, 10, 1, 7, 59, 59)),
+            Assert.That(freeBusy.GetFreeBusyStatus(new CalDateTime(2025, 10, 1, 7, 59, 59).ToTimeZone("America/New_York")),
                 Is.EqualTo(FreeBusyStatus.Free));
-            Assert.That(freeBusy.GetFreeBusyStatus(new CalDateTime(2025, 10, 1, 8, 0, 0)),
+            Assert.That(freeBusy.GetFreeBusyStatus(new CalDateTime(2025, 10, 1, 8, 0, 0).ToTimeZone("America/New_York")),
                 Is.EqualTo(FreeBusyStatus.Busy));
-            Assert.That(freeBusy.GetFreeBusyStatus(new CalDateTime(2025, 10, 1, 8, 59, 59)),
+            Assert.That(freeBusy.GetFreeBusyStatus(new CalDateTime(2025, 10, 1, 8, 59, 59).ToTimeZone("America/New_York")),
                 Is.EqualTo(FreeBusyStatus.Busy));
-            Assert.That(freeBusy.GetFreeBusyStatus(new CalDateTime(2025, 10, 1, 9, 0, 0)),
+            Assert.That(freeBusy.GetFreeBusyStatus(new CalDateTime(2025, 10, 1, 9, 0, 0).ToTimeZone("America/New_York")),
                 Is.EqualTo(FreeBusyStatus.Free));
         });
     }
@@ -54,34 +58,142 @@ public void GetFreeBusyStatusByPeriod()
         evt.End = new CalDateTime(2025, 6, 1, 10, 0, 0);
 
         var freeBusy = cal.GetFreeBusy(
-            new CalDateTime(2025, 6, 1, 0, 0, 0),
-            new CalDateTime(2025, 6, 7, 0, 0, 0))!;
+            DateUtil.GetZone("UTC"),
+            new CalDateTime(2025, 6, 1, 0, 0, 0, "UTC"),
+            new CalDateTime(2025, 6, 7, 0, 0, 0, "UTC"))!;
 
         Assert.Multiple(() =>
         {
             // Period completely before the event (ends when event starts)
-            var periodBefore = new Period(new CalDateTime(2025, 6, 1, 7, 0, 0),
-                                          new CalDateTime(2025, 6, 1, 8, 0, 0));
+            var periodBefore = new Period(new CalDateTime(2025, 6, 1, 7, 0, 0, "UTC"),
+                                          new CalDateTime(2025, 6, 1, 8, 0, 0, "UTC"));
             Assert.That(freeBusy.GetFreeBusyStatus(periodBefore),
                 Is.EqualTo(FreeBusyStatus.Free));
 
             // Period entirely within the event (should be busy)
-            var periodDuring = new Period(new CalDateTime(2025, 6, 1, 8, 0, 0),
-                                          new CalDateTime(2025, 6, 1, 8, 59, 59));
+            var periodDuring = new Period(new CalDateTime(2025, 6, 1, 8, 0, 0, "UTC"),
+                                          new CalDateTime(2025, 6, 1, 8, 59, 59, "UTC"));
             Assert.That(freeBusy.GetFreeBusyStatus(periodDuring),
                 Is.EqualTo(FreeBusyStatus.Busy));
 
             // Period spanning before and into the event (should be busy)
-            var periodSpanningStart = new Period(new CalDateTime(2025, 6, 1, 7, 59, 59),
-                                                 new CalDateTime(2025, 6, 1, 8, 30, 0));
+            var periodSpanningStart = new Period(new CalDateTime(2025, 6, 1, 7, 59, 59, "UTC"),
+                                                 new CalDateTime(2025, 6, 1, 8, 30, 0, "UTC"));
             Assert.That(freeBusy.GetFreeBusyStatus(periodSpanningStart),
                 Is.EqualTo(FreeBusyStatus.Busy));
 
             // Period starting at the event's end (should be free)
-            var periodAfter = new Period(new CalDateTime(2025, 6, 1, 10, 0, 0),
-                                         new CalDateTime(2025, 6, 1, 12, 0, 0));
+            var periodAfter = new Period(new CalDateTime(2025, 6, 1, 10, 0, 0, "UTC"),
+                                         new CalDateTime(2025, 6, 1, 12, 0, 0, "UTC"));
             Assert.That(freeBusy.GetFreeBusyStatus(periodAfter),
                 Is.EqualTo(FreeBusyStatus.Free));
         });
     }
+
+    [Test]
+    public void Contains_Tests()
+    {
+        var start = NodaTime.Instant.FromUtc(2025, 1, 1, 0, 0);
+        var dtBefore = start.InUtc().PlusSeconds(-1).ToInstant();
+        var dtAtStart = start;
+        var dtMid = start.InUtc().PlusMinutes(30).ToInstant();
+        var dtAtEnd = start.InUtc().PlusHours(1).ToInstant();
+        var dtAfter = start.InUtc().PlusHours(1).PlusSeconds(1).ToInstant();
+
+        // Period with duration: effective end time = start + 1 hour (exclusive)
+        var periodWithDuration = new FreeBusyEntry(new(new(start), Duration.FromHours(1)), FreeBusyStatus.Free);
+        Assert.Multiple(() =>
+        {
+            Assert.That(periodWithDuration.Contains(null), Is.False, "Contains should return false for null dt.");
+            Assert.That(periodWithDuration.Contains(dtBefore), Is.False, "Contains should return false if dt is before start.");
+            Assert.That(periodWithDuration.Contains(dtAtStart), Is.True, "Contains should return true for dt equal to start.");
+            Assert.That(periodWithDuration.Contains(dtMid), Is.True, "Contains should return true for dt in the middle.");
+            Assert.That(periodWithDuration.Contains(dtAtEnd), Is.False, "Contains should return false for dt equal to effective end (exclusive).");
+            Assert.That(periodWithDuration.Contains(dtAfter), Is.False, "Contains should return false for dt after effective end.");
+        });
+    }
+
+
+    [Test, TestCaseSource(nameof(CollidesWithPeriodTestCases))]
+    public void CollidesWithPeriod(Period period1, Period? period2, bool expected)
+    {
+        var f1 = new FreeBusyEntry(period1, FreeBusyStatus.Free);
+        var f2 = period2 is null ? null : new FreeBusyEntry(period2, FreeBusyStatus.Free);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(f1.CollidesWith(f2), Is.EqualTo(expected));
+
+            Assert.That(f2?.CollidesWith(f1) == true, Is.EqualTo(expected));
+        });
+    }
+
+    private static IEnumerable<TestCaseData> CollidesWithPeriodTestCases
+    {
+        get
+        {
+            // Overlapping periods
+            yield return new TestCaseData(
+                new Period(new CalDateTime(2025, 1, 1, 0, 0, 0, "UTC"), Duration.FromHours(2)),
+                new Period(new CalDateTime(2025, 1, 1, 1, 0, 0, "UTC"), Duration.FromHours(2)),
+                true
+            ).SetName("Overlap: period1 and period2 overlap by 1 hour");
+
+            // Contiguous periods (end of one is start of another, exclusive end)
+            yield return new TestCaseData(
+                new Period(new CalDateTime(2025, 1, 1, 0, 0, 0, "UTC"), Duration.FromHours(1)),
+                new Period(new CalDateTime(2025, 1, 1, 1, 0, 0, "UTC"), Duration.FromHours(1)),
+                false
+            ).SetName("Contiguous: period1 ends when period2 starts (no overlap)");
+
+            // One inside another
+            yield return new TestCaseData(
+                new Period(new CalDateTime(2025, 1, 1, 0, 0, 0, "UTC"), Duration.FromHours(4)),
+                new Period(new CalDateTime(2025, 1, 1, 1, 0, 0, "UTC"), Duration.FromHours(1)),
+                true
+            ).SetName("Contained: period2 is inside period1");
+
+            // Identical periods
+            yield return new TestCaseData(
+                new Period(new CalDateTime(2025, 1, 1, 0, 0, 0, "UTC"), Duration.FromHours(2)),
+                new Period(new CalDateTime(2025, 1, 1, 0, 0, 0, "UTC"), Duration.FromHours(2)),
+                true
+            ).SetName("Identical: periods are exactly the same");
+
+            // Non-overlapping periods
+            yield return new TestCaseData(
+                new Period(new CalDateTime(2025, 1, 1, 0, 0, 0, "UTC"), Duration.FromHours(1)),
+                new Period(new CalDateTime(2025, 1, 1, 2, 0, 0, "UTC"), Duration.FromHours(1)),
+                false
+            ).SetName("NoOverlap: periods are completely separate");
+
+            // This Duration is zero (point in time)
+            yield return new TestCaseData(
+                new Period(new CalDateTime(2025, 1, 1, 0, 0, 0, "UTC"), Duration.Zero),
+                new Period(new CalDateTime(2025, 1, 1, 0, 0, 0, "UTC"), Duration.FromHours(1)),
+                false
+            ).SetName("NoOverlap: this duration is zero");
+
+            // Other Duration is zero (point in time)
+            yield return new TestCaseData(
+                new Period(new CalDateTime(2025, 1, 1, 0, 0, 0, "UTC"), Duration.FromHours(1)),
+                new Period(new CalDateTime(2025, 1, 1, 0, 0, 0, "UTC"), Duration.Zero),
+                false
+            ).SetName("NoOverlap: other duration is zero");
+
+            // other period is null
+            yield return new TestCaseData(
+                new Period(new CalDateTime(2025, 1, 1, 0, 0, 0, "UTC"), Duration.FromHours(1)),
+                null,
+                false
+            ).SetName("NoOverlap: other period is null");
+
+        }
+    }
+
+    [Test]
+    public void PeriodCollidesWith_WhenNoDurationShouldThrow()
+    {
+        Assert.Throws<ArgumentException>(() => _ = new FreeBusyEntry(new(new CalDateTime(2025, 1, 1, 0, 0, 0, "UTC")), FreeBusyStatus.Free));
+    }
 }
diff --git a/Ical.Net.Tests/Logging/ToLogExtensions.cs b/Ical.Net.Tests/Logging/ToLogExtensions.cs
index 802847660..3b05803ee 100644
--- a/Ical.Net.Tests/Logging/ToLogExtensions.cs
+++ b/Ical.Net.Tests/Logging/ToLogExtensions.cs
@@ -50,9 +50,8 @@ public static string ToLog(this IEnumerable<Occurrence>? occurrences)
     public static string ToLog(this Occurrence occurrence)
     {
         return $"""
-                Start: {occurrence.Period.StartTime}
-                  Period: {occurrence.Period.Duration?.ToString() ?? "null"}
-                  End: {occurrence.Period.EffectiveEndTime ?? occurrence.Period.StartTime.Add(occurrence.Period.Duration!.Value)}
+                Start: {occurrence.Start}
+                  End: {occurrence.End}
                 """;
     }
 }
diff --git a/Ical.Net.Tests/MatchTimeZoneTests.cs b/Ical.Net.Tests/MatchTimeZoneTests.cs
index a3dc9a62a..f857087a9 100644
--- a/Ical.Net.Tests/MatchTimeZoneTests.cs
+++ b/Ical.Net.Tests/MatchTimeZoneTests.cs
@@ -83,12 +83,13 @@ public void MatchTimeZone_LocalTimeAustraliaWithTimeZone(string inputUntil, int
         var evt = calendar.Events.First();
         var until = evt.RecurrenceRules.First().Until;
 
-        var expectedUntil = DateTime.ParseExact(inputUntil, "yyyyMMddTHHmmssZ",
+        var expectedUntil = new CalDateTime(DateTime.ParseExact(inputUntil, "yyyyMMddTHHmmssZ",
             System.Globalization.CultureInfo.InvariantCulture,
             System.Globalization.DateTimeStyles.AssumeUniversal |
-            System.Globalization.DateTimeStyles.AdjustToUniversal).AsCalDateTime();
+            System.Globalization.DateTimeStyles.AdjustToUniversal));
         
-        var occurrences = evt.GetOccurrences(new CalDateTime(2024, 10, 01)).TakeWhileBefore(new CalDateTime(2024, 10, 07));
+        var occurrences = evt.GetOccurrences(new CalDateTime(2024, 10, 01).ToZonedDateTime("Australia/Sydney"))
+            .TakeWhileBefore(new CalDateTime(2024, 10, 07));
 
         Assert.Multiple(() =>
         {
diff --git a/Ical.Net.Tests/PeriodTests.cs b/Ical.Net.Tests/PeriodTests.cs
index a03c916a5..806365ad2 100644
--- a/Ical.Net.Tests/PeriodTests.cs
+++ b/Ical.Net.Tests/PeriodTests.cs
@@ -7,6 +7,7 @@
 using System;
 using System.Collections.Generic;
 using Ical.Net.DataTypes;
+using Ical.Net.Evaluation;
 using NUnit.Framework;
 
 namespace Ical.Net.Tests;
@@ -28,15 +29,10 @@ public void CreatePeriodWithArguments()
             Assert.That(period.Duration, Is.Null);
             
             Assert.That(periodWithEndTime.StartTime, Is.EqualTo(new CalDateTime(2025, 1, 1, 0, 0, 0, "America/New_York")));
-            Assert.That(periodWithEndTime.EffectiveEndTime, Is.EqualTo(new CalDateTime(2025, 1, 1, 1, 0, 0, "America/New_York")));
-            Assert.That(periodWithEndTime.EffectiveDuration, Is.EqualTo(Duration.FromHours(1)));
 
             Assert.That(periodWithDuration.StartTime, Is.EqualTo(new CalDateTime(2025, 1, 1, 0, 0, 0, "America/New_York")));
-            Assert.That(periodWithDuration.EffectiveEndTime, Is.EqualTo(new CalDateTime(2025, 1, 1, 1, 0, 0, "America/New_York")));
-            Assert.That(periodWithDuration.EffectiveDuration, Is.EqualTo(Duration.FromHours(1)));
 
             Assert.That(Period.Create(period.StartTime).Duration, Is.Null);
-            Assert.That(Period.Create(period.StartTime).EffectiveDuration, Is.Null);
         });
     }
 
@@ -90,137 +86,29 @@ public void Timezones_StartTime_EndTime_MustBeEqual()
     [Test]
     public void CompareTo_ReturnsExpectedValues()
     {
-        var dt = new CalDateTime(2025, 6, 1, 0, 0, 0, "Europe/Vienna");
+        var dt = new CalDateTime(2025, 6, 1, 0, 0, 0, "Europe/Vienna")
+            .ToZonedDateTime();
 
         Assert.Multiple(() =>
         {
-            Assert.That(new Period(dt).CompareTo(null),
+            Assert.That(new EvaluationPeriod(dt).CompareTo(null),
                 Is.EqualTo(1));
-            Assert.That(new Period(dt).CompareTo(new Period(dt)),
+            Assert.That(new EvaluationPeriod(dt).CompareTo(new EvaluationPeriod(dt)),
                 Is.EqualTo(0));
-            Assert.That(new Period(dt).CompareTo(new Period(dt.AddHours(-1))),
+            Assert.That(new EvaluationPeriod(dt).CompareTo(new EvaluationPeriod(dt.PlusHours(-1))),
                 Is.EqualTo(1));
-            Assert.That(new Period(dt).CompareTo(new Period(dt.AddHours(1))),
+            Assert.That(new EvaluationPeriod(dt).CompareTo(new EvaluationPeriod(dt.PlusHours(1))),
                 Is.EqualTo(-1));
         });
     }
 
-    [Test, TestCaseSource(nameof(CollidesWithPeriodTestCases))]
-    public void CollidesWithPeriod(Period period1, Period? period2, bool expected)
-    {
-        Assert.Multiple(() =>
-        {
-            Assert.That(period1.CollidesWith(period2), Is.EqualTo(expected));
-            Assert.That(period2?.CollidesWith(period1) == true, Is.EqualTo(expected));
-        });
-    }
-
-    private static IEnumerable<TestCaseData> CollidesWithPeriodTestCases
-    {
-        get
-        {
-            // Overlapping periods
-            yield return new TestCaseData(
-                new Period(new CalDateTime(2025, 1, 1, 0, 0, 0), Duration.FromHours(2)),
-                new Period(new CalDateTime(2025, 1, 1, 1, 0, 0), Duration.FromHours(2)),
-                true
-            ).SetName("Overlap: period1 and period2 overlap by 1 hour");
-
-            // Contiguous periods (end of one is start of another, exclusive end)
-            yield return new TestCaseData(
-                new Period(new CalDateTime(2025, 1, 1, 0, 0, 0), Duration.FromHours(1)),
-                new Period(new CalDateTime(2025, 1, 1, 1, 0, 0), Duration.FromHours(1)),
-                false
-            ).SetName("Contiguous: period1 ends when period2 starts (no overlap)");
-
-            // One inside another
-            yield return new TestCaseData(
-                new Period(new CalDateTime(2025, 1, 1, 0, 0, 0), Duration.FromHours(4)),
-                new Period(new CalDateTime(2025, 1, 1, 1, 0, 0), Duration.FromHours(1)),
-                true
-            ).SetName("Contained: period2 is inside period1");
-
-            // Identical periods
-            yield return new TestCaseData(
-                new Period(new CalDateTime(2025, 1, 1, 0, 0, 0), Duration.FromHours(2)),
-                new Period(new CalDateTime(2025, 1, 1, 0, 0, 0), Duration.FromHours(2)),
-                true
-            ).SetName("Identical: periods are exactly the same");
-
-            // Non-overlapping periods
-            yield return new TestCaseData(
-                new Period(new CalDateTime(2025, 1, 1, 0, 0, 0), Duration.FromHours(1)),
-                new Period(new CalDateTime(2025, 1, 1, 2, 0, 0), Duration.FromHours(1)),
-                false
-            ).SetName("NoOverlap: periods are completely separate");
-
-            // This Duration is zero (point in time)
-            yield return new TestCaseData(
-                new Period(new CalDateTime(2025, 1, 1, 0, 0, 0), Duration.Zero),
-                new Period(new CalDateTime(2025, 1, 1, 0, 0, 0), Duration.FromHours(1)),
-                false
-            ).SetName("NoOverlap: this duration is zero");
-
-            // Other Duration is zero (point in time)
-            yield return new TestCaseData(
-                new Period(new CalDateTime(2025, 1, 1, 0, 0, 0), Duration.FromHours(1)),
-                new Period(new CalDateTime(2025, 1, 1, 0, 0, 0), Duration.Zero),
-                false
-            ).SetName("NoOverlap: other duration is zero");
-
-            // other period is null
-            yield return new TestCaseData(
-                new Period(new CalDateTime(2025, 1, 1, 0, 0, 0), Duration.FromHours(1)),
-                null,
-                false
-            ).SetName("NoOverlap: other period is null");
-
-        }
-    }
-
-    [Test]
-    public void PeriodCollidesWith_WhenNoDurationShouldThrow()
-    {
-        var period1 = new Period(new CalDateTime(2025, 1, 1, 0, 0, 0), Duration.FromHours(2));
-        var period2 = new Period(new CalDateTime(2025, 1, 1, 0, 0, 0));
 
-        Assert.Multiple(() =>
-        {
-            Assert.Throws<ArgumentException>(() => _ = period1.CollidesWith(period2));
-            Assert.Throws<ArgumentException>(() => _ = period2.CollidesWith(period1));
-        });
-    }
 
     [Test]
-    public void EffectiveEndTime_WithoutDuration_ShouldBeNull()
+    public void HasEndOrDuration_WithoutDuration_ShouldBeFalse()
     {
         var period = new Period(new CalDateTime(2025, 7, 1, 12, 0, 0));
-        Assert.That(period.EffectiveEndTime, Is.Null, "EffectiveEndTime should be null when no duration is set.");
-    }
-
-    [Test]
-    public void Contains_Tests()
-    {
-        var start = new CalDateTime(2025, 1, 1, 0, 0, 0, CalDateTime.UtcTzId);
-        var dtBefore = start.AddSeconds(-1);
-        var dtAtStart = start;
-        var dtMid = start.AddMinutes(30);
-        var dtAtEnd = start.AddHours(1);
-        var dtAfter = start.AddHours(1).AddSeconds(1);
-
-        // Period with duration: effective end time = start + 1 hour (exclusive)
-        var periodWithDuration = new Period(start, Duration.FromHours(1));
-        var periodWithoutDuration = new Period(start);
-        Assert.Multiple(() =>
-        {
-            Assert.That(periodWithDuration.Contains(null), Is.False, "Contains should return false for null dt.");
-            Assert.That(periodWithDuration.Contains(dtBefore), Is.False, "Contains should return false if dt is before start.");
-            Assert.That(periodWithDuration.Contains(dtAtStart), Is.True, "Contains should return true for dt equal to start.");
-            Assert.That(periodWithDuration.Contains(dtMid), Is.True, "Contains should return true for dt in the middle.");
-            Assert.That(periodWithDuration.Contains(dtAtEnd), Is.False, "Contains should return false for dt equal to effective end (exclusive).");
-            Assert.That(periodWithDuration.Contains(dtAfter), Is.False, "Contains should return false for dt after effective end.");
-            Assert.That(periodWithoutDuration.Contains(dtAtStart), Is.True, "Contains should return true for self without effective end");
-        });
+        Assert.That(period.HasEndOrDuration, Is.False, "HasEndOrDuration should be false when no duration is set.");
     }
 
     [Test]
diff --git a/Ical.Net.Tests/ProgramTest.cs b/Ical.Net.Tests/ProgramTest.cs
index 5612dd728..0ed94f546 100644
--- a/Ical.Net.Tests/ProgramTest.cs
+++ b/Ical.Net.Tests/ProgramTest.cs
@@ -52,60 +52,36 @@ public void Merge1()
 
         // Get occurrences for the first event
         var occurrences = evt1.GetOccurrences(
-            new CalDateTime(1996, 1, 1))
-            .TakeWhileBefore(new CalDateTime(2000, 1, 1)).ToList();
+            new CalDateTime(1996, 1, 1).ToZonedDateTime(_tzid))
+            .TakeWhileBefore(new CalDateTime(2000, 1, 1).ToZonedDateTime(_tzid).ToInstant()).ToList();
 
         var dateTimes = new[]
         {
-            new CalDateTime(1997, 9, 10, 9, 0, 0, _tzid),
-            new CalDateTime(1997, 9, 11, 9, 0, 0, _tzid),
-            new CalDateTime(1997, 9, 12, 9, 0, 0, _tzid),
-            new CalDateTime(1997, 9, 13, 9, 0, 0, _tzid),
-            new CalDateTime(1997, 9, 14, 9, 0, 0, _tzid),
-            new CalDateTime(1997, 9, 15, 9, 0, 0, _tzid),
-            new CalDateTime(1999, 3, 10, 9, 0, 0, _tzid),
-            new CalDateTime(1999, 3, 11, 9, 0, 0, _tzid),
-            new CalDateTime(1999, 3, 12, 9, 0, 0, _tzid),
-            new CalDateTime(1999, 3, 13, 9, 0, 0, _tzid)
-        };
-
-        var timeZones = new[]
-        {
-            "US-Eastern",
-            "US-Eastern",
-            "US-Eastern",
-            "US-Eastern",
-            "US-Eastern",
-            "US-Eastern",
-            "US-Eastern",
-            "US-Eastern",
-            "US-Eastern",
-            "US-Eastern"
+            new CalDateTime(1997, 9, 10, 9, 0, 0, _tzid).ToZonedDateTime(),
+            new CalDateTime(1997, 9, 11, 9, 0, 0, _tzid).ToZonedDateTime(),
+            new CalDateTime(1997, 9, 12, 9, 0, 0, _tzid).ToZonedDateTime(),
+            new CalDateTime(1997, 9, 13, 9, 0, 0, _tzid).ToZonedDateTime(),
+            new CalDateTime(1997, 9, 14, 9, 0, 0, _tzid).ToZonedDateTime(),
+            new CalDateTime(1997, 9, 15, 9, 0, 0, _tzid).ToZonedDateTime(),
+            new CalDateTime(1999, 3, 10, 9, 0, 0, _tzid).ToZonedDateTime(),
+            new CalDateTime(1999, 3, 11, 9, 0, 0, _tzid).ToZonedDateTime(),
+            new CalDateTime(1999, 3, 12, 9, 0, 0, _tzid).ToZonedDateTime(),
+            new CalDateTime(1999, 3, 13, 9, 0, 0, _tzid).ToZonedDateTime(),
         };
 
         for (var i = 0; i < dateTimes.Length; i++)
         {
-            CalDateTime dt = dateTimes[i];
-            var start = occurrences[i].Period.StartTime;
+            var dt = dateTimes[i];
+            var start = occurrences[i].Start;
             Assert.That(start, Is.EqualTo(dt));
-
-            var expectedZone = DateUtil.GetZone(dt.TimeZoneName);
-            var actualZone = DateUtil.GetZone(timeZones[i]);
-
-            //Assert.AreEqual();
-
-            //Normalize the time zones and then compare equality
-            Assert.That(actualZone, Is.EqualTo(expectedZone));
-
-            //Assert.IsTrue(dt.TimeZoneName == TimeZones[i], "Event " + dt + " should occur in the " + TimeZones[i] + " timezone");
         }
 
         Assert.That(occurrences.Count == dateTimes.Length, Is.True, "There should be exactly " + dateTimes.Length + " occurrences; there were " + occurrences.Count);
 
         // Get occurrences for the 2nd event
         occurrences = evt2.GetOccurrences(
-            new CalDateTime(1996, 1, 1))
-            .TakeWhileBefore(new CalDateTime(1998, 4, 1)).ToList();
+            new CalDateTime(1996, 1, 1).ToZonedDateTime(_tzid))
+            .TakeWhileBefore(new CalDateTime(1998, 4, 1).ToZonedDateTime(_tzid).ToInstant()).ToList();
 
         var dateTimes1 = new[]
         {
@@ -127,38 +103,15 @@ public void Merge1()
             new CalDateTime(1998, 3, 17, 9, 0, 0, _tzid),
             new CalDateTime(1998, 3, 24, 9, 0, 0, _tzid),
             new CalDateTime(1998, 3, 31, 9, 0, 0, _tzid)
-        };
-
-        var timeZones1 = new[]
-        {
-            "US-Eastern",
-            "US-Eastern",
-            "US-Eastern",
-            "US-Eastern",
-            "US-Eastern",
-            "US-Eastern",
-            "US-Eastern",
-            "US-Eastern",
-            "US-Eastern",
-            "US-Eastern",
-            "US-Eastern",
-            "US-Eastern",
-            "US-Eastern",
-            "US-Eastern",
-            "US-Eastern",
-            "US-Eastern",
-            "US-Eastern",
-            "US-Eastern"
-        };
+        }.Select(x => x.ToZonedDateTime()).ToArray();
 
         for (var i = 0; i < dateTimes1.Length; i++)
         {
-            CalDateTime dt = dateTimes1[i];
-            var start = occurrences[i].Period.StartTime;
+            var dt = dateTimes1[i];
+            var start = occurrences[i].Start;
             Assert.Multiple(() =>
             {
                 Assert.That(start, Is.EqualTo(dt));
-                Assert.That(dt.TimeZoneName == timeZones1[i], Is.True, "Event " + dt + " should occur in the " + timeZones1[i] + " timezone");
             });
         }
 
diff --git a/Ical.Net.Tests/RecurrenceTests.cs b/Ical.Net.Tests/RecurrenceTests.cs
index 154eecd9d..2e6e0cd4d 100644
--- a/Ical.Net.Tests/RecurrenceTests.cs
+++ b/Ical.Net.Tests/RecurrenceTests.cs
@@ -16,8 +16,13 @@
 using Ical.Net.Serialization;
 using Ical.Net.Serialization.DataTypes;
 using Ical.Net.Tests.TestHelpers;
+using Ical.Net.Utility;
+using NodaTime;
+using NodaTime.Extensions;
 using NUnit.Framework;
 using NUnit.Framework.Constraints;
+using Duration = Ical.Net.DataTypes.Duration;
+using Period = Ical.Net.DataTypes.Period;
 
 namespace Ical.Net.Tests;
 
@@ -31,17 +36,17 @@ private void EventOccurrenceTest(
         CalDateTime? fromDate,
         CalDateTime? toDate,
         Period[] expectedPeriods,
-        string[]? timeZones,
-        int eventIndex
-    ) => OccurrenceTester.AssertOccurrences(cal, fromDate, toDate, expectedPeriods, timeZones, eventIndex);
+        int eventIndex,
+        string? timeZone = null
+    ) => OccurrenceTester.AssertOccurrences(cal, fromDate, toDate, expectedPeriods, eventIndex, timeZone);
 
     private void EventOccurrenceTest(
         Calendar cal,
         CalDateTime? fromDate,
         CalDateTime? toDate,
         Period[] expectedPeriods,
-        string[]? timeZones
-    ) => OccurrenceTester.AssertOccurrences(cal, fromDate, toDate, expectedPeriods, timeZones, 0);
+        string? timeZone = null
+    ) => OccurrenceTester.AssertOccurrences(cal, fromDate, toDate, expectedPeriods, 0, timeZone);
 
     private static readonly TestCaseData[] EventOccurrenceTestCases =
     [
@@ -86,7 +91,7 @@ p.Duration is null
                     : new Period(p.StartTime.ToTimeZone(tzid), p.Duration.Value))
             .ToArray();
 
-        EventOccurrenceTest(cal, null, null, periods, null, 0);
+        EventOccurrenceTest(cal, null, null, periods, 0);
     }
 
     /// <summary>
@@ -98,30 +103,33 @@ public void YearlyComplex1()
         var iCal = Calendar.Load(IcsFiles.YearlyComplex1)!;
         ProgramTest.TestCal(iCal);
         var evt = iCal.Events.First();
-        var occurrences = evt.GetOccurrences(
-                new CalDateTime(2006, 1, 1))
-            .TakeWhileBefore(new CalDateTime(2011, 1, 1)).ToList();
 
-        var dt = new CalDateTime(2007, 1, 1, 8, 30, 0, _tzid);
+        var start = new CalDateTime(2006, 1, 1).ToZonedDateTime(_tzid);
+        var occurrences = evt.GetOccurrences(start)
+            .TakeWhileBefore(new CalDateTime(2011, 1, 1).ToZonedDateTime(_tzid).ToInstant())
+            .ToList();
+
+        var dt = new CalDateTime(2007, 1, 1, 8, 30, 0).ToLocalDateTime();
         var i = 0;
 
         while (dt.Year < 2011)
         {
-            if (dt.GreaterThan(evt.Start!) &&
+            if (dt > evt.Start!.ToLocalDateTime() &&
                 (dt.Year % 2 == 1) && // Every-other year from 2005
                 (dt.Month == 1) &&
-                (dt.DayOfWeek == DayOfWeek.Sunday))
+                (dt.DayOfWeek.ToDayOfWeek() == DayOfWeek.Sunday))
             {
-                var dt1 = dt.AddHours(1);
+                var expectedStart = dt.InZoneLeniently(start.Zone);
+                var dt1 = dt.PlusHours(1).InZoneLeniently(start.Zone);
                 Assert.Multiple(() =>
                 {
-                    Assert.That(occurrences[i].Period.StartTime, Is.EqualTo(dt), "Event should occur at " + dt);
-                    Assert.That(occurrences[i + 1].Period.StartTime, Is.EqualTo(dt1), "Event should occur at " + dt);
+                    Assert.That(occurrences[i].Start, Is.EqualTo(expectedStart), "Event should occur at " + expectedStart);
+                    Assert.That(occurrences[i + 1].Start, Is.EqualTo(dt1), "Event should occur at " + dt1);
                 });
                 i += 2;
             }
 
-            dt = dt.AddDays(1);
+            dt = dt.PlusDays(1);
         }
     }
 
@@ -147,8 +155,7 @@ public void DailyCount1()
                 new(new CalDateTime(2006, 08, 01, 10, 00, 00, _tzid), Duration.FromHours(1)),
                 new(new CalDateTime(2006, 08, 03, 10, 00, 00, _tzid), Duration.FromHours(1)),
                 new(new CalDateTime(2006, 08, 05, 10, 00, 00, _tzid), Duration.FromHours(1))
-            ],
-            null
+            ]
         );
     }
 
@@ -163,30 +170,25 @@ public void DailyUntil1()
         var evt = iCal.Events.First();
 
         var occurrences = evt.GetOccurrences(
-                new CalDateTime(1997, 9, 1))
-            .TakeWhileBefore(new CalDateTime(1998, 1, 1)).ToList();
+            new CalDateTime(1997, 9, 1).ToZonedDateTime(_tzid))
+            .TakeWhileBefore(new CalDateTime(1998, 1, 1).ToZonedDateTime(_tzid).ToInstant())
+            .ToList();
 
-        var dt = new CalDateTime(1997, 9, 2, 9, 0, 0, _tzid);
+        var dt = new CalDateTime(1997, 9, 2, 9, 0, 0).ToZonedDateTime(_tzid);
         var i = 0;
         while (dt.Year < 1998)
         {
-            if (dt.GreaterThanOrEqual(evt.Start!) &&
-                dt.LessThan(new CalDateTime(1997, 12, 24, 0, 0, 0, _tzid)))
+            if (dt.ToInstant() >= evt.Start!.ToZonedDateTime(_tzid).ToInstant() &&
+                dt.ToInstant() < new CalDateTime(1997, 12, 24, 0, 0, 0).ToZonedDateTime(_tzid).ToInstant())
             {
-                Assert.Multiple(() =>
-                {
-                    Assert.That(occurrences[i].Period.StartTime, Is.EqualTo(dt), "Event should occur at " + dt);
-                    Assert.That(
-                        (dt.LessThan(new CalDateTime(1997, 10, 26)) && dt.TimeZoneName == "US-Eastern") ||
-                        (dt.GreaterThan(new CalDateTime(1997, 10, 26)) && dt.TimeZoneName == "US-Eastern"),
-                        Is.True,
-                        "Event " + dt +
-                        " doesn't occur in the correct time zone (including Daylight & Standard time zones)");
-                });
+                Assert.That(occurrences[i].Start, Is.EqualTo(dt), "Event should occur at " + dt);
+
                 i++;
             }
 
-            dt = dt.AddDays(1);
+            dt = dt.LocalDateTime
+                .PlusDays(1)
+                .InZoneLeniently(_tzid);
         }
     }
 
@@ -249,57 +251,7 @@ public void Daily1()
                 new(new CalDateTime(1997, 11, 29, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new(new CalDateTime(1997, 12, 1, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new(new CalDateTime(1997, 12, 3, 9, 0, 0, _tzid), Duration.FromHours(1))
-            ],
-            new[]
-            {
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern"
-            }
+            ]
         );
     }
 
@@ -320,8 +272,7 @@ public void DailyCount2()
                 new(new CalDateTime(1997, 9, 22, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new(new CalDateTime(1997, 10, 2, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new(new CalDateTime(1997, 10, 12, 9, 0, 0, _tzid), Duration.FromHours(1))
-            ],
-            null
+            ]
         );
     }
 
@@ -336,22 +287,25 @@ public void ByMonth1()
         var evt = iCal.Events.First();
 
         var occurrences = evt.GetOccurrences(
-                new CalDateTime(1998, 1, 1))
-            .TakeWhileBefore(new CalDateTime(2000, 12, 31)).ToList();
+            new CalDateTime(1998, 1, 1).ToZonedDateTime(_tzid))
+            .TakeWhileBefore(new CalDateTime(2000, 12, 31).ToZonedDateTime(_tzid).ToInstant())
+            .ToList();
 
-        var dt = new CalDateTime(1998, 1, 1, 9, 0, 0, _tzid);
+        var dt = new CalDateTime(1998, 1, 1, 9, 0, 0, _tzid).ToZonedDateTime();
         var i = 0;
         while (dt.Year < 2001)
         {
-            if (dt.GreaterThanOrEqual(evt.Start!) &&
+            if (dt.ToInstant() >= evt.Start!.ToZonedDateTime(_tzid).ToInstant() &&
                 dt.Month == 1 &&
-                dt.LessThanOrEqual(new CalDateTime(2000, 1, 31, 9, 0, 0, _tzid)))
+                dt.ToInstant() <= new CalDateTime(2000, 1, 31, 9, 0, 0, _tzid).ToZonedDateTime().ToInstant())
             {
-                Assert.That(occurrences[i].Period.StartTime, Is.EqualTo(dt), "Event should occur at " + dt);
+                Assert.That(occurrences[i].Start, Is.EqualTo(dt), "Event should occur at " + dt);
                 i++;
             }
 
-            dt = dt.AddDays(1);
+            dt = dt.LocalDateTime
+                .PlusDays(1)
+                .InZoneLeniently(_tzid);
         }
     }
 
@@ -407,20 +361,7 @@ public void WeeklyCount1()
                 new(new CalDateTime(1997, 10, 21, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new(new CalDateTime(1997, 10, 28, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new(new CalDateTime(1997, 11, 4, 9, 0, 0, _tzid), Duration.FromHours(1))
-            ],
-            new[]
-            {
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern"
-            }
+            ]
         );
     }
 
@@ -453,27 +394,7 @@ public void WeeklyUntil1()
                 new(new CalDateTime(1997, 12, 9, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new(new CalDateTime(1997, 12, 16, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new(new CalDateTime(1997, 12, 23, 9, 0, 0, _tzid), Duration.FromHours(1))
-            ],
-            new[]
-            {
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern"
-            }
+            ]
         );
     }
 
@@ -501,20 +422,6 @@ public void WeeklyWkst1()
                 new Period(new CalDateTime(1997, 12, 23, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1998, 1, 6, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1998, 1, 20, 9, 0, 0, _tzid), Duration.FromHours(1))
-            },
-            new[]
-            {
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern"
             }
         );
     }
@@ -542,8 +449,7 @@ public void WeeklyUntilWkst1()
                 new Period(new CalDateTime(1997, 9, 25, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1997, 9, 30, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1997, 10, 2, 9, 0, 0, _tzid), Duration.FromHours(1))
-            },
-            null
+            }
         );
     }
 
@@ -611,34 +517,6 @@ public void WeeklyUntilWkst2()
                 new Period(new CalDateTime(1997, 12, 10, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1997, 12, 12, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1997, 12, 22, 9, 0, 0, _tzid), Duration.FromHours(1))
-            },
-            new[]
-            {
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern"
             }
         );
     }
@@ -678,31 +556,6 @@ public void WeeklyUntilWkst2_1()
                 new Period(new CalDateTime(1997, 12, 10, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1997, 12, 12, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1997, 12, 22, 9, 0, 0, _tzid), Duration.FromHours(1))
-            },
-            new[]
-            {
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern"
             }
         );
     }
@@ -728,8 +581,7 @@ public void WeeklyCountWkst2()
                 new Period(new CalDateTime(1997, 10, 2, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1997, 10, 14, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1997, 10, 16, 9, 0, 0, _tzid), Duration.FromHours(1))
-            },
-            null
+            }
         );
     }
 
@@ -756,19 +608,6 @@ public void MonthlyCountByDay1()
                 new Period(new CalDateTime(1998, 4, 3, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1998, 5, 1, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1998, 6, 5, 9, 0, 0, _tzid), Duration.FromHours(1))
-            },
-            new[]
-            {
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern"
             }
         );
     }
@@ -790,13 +629,6 @@ public void MonthlyUntilByDay1()
                 new Period(new CalDateTime(1997, 10, 3, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1997, 11, 7, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1997, 12, 5, 9, 0, 0, _tzid), Duration.FromHours(1))
-            },
-            new[]
-            {
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern"
             }
         );
     }
@@ -824,19 +656,6 @@ public void MonthlyCountByDay2()
                 new Period(new CalDateTime(1998, 3, 29, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1998, 5, 3, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1998, 5, 31, 9, 0, 0, _tzid), Duration.FromHours(1))
-            },
-            new[]
-            {
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern"
             }
         );
     }
@@ -860,15 +679,6 @@ public void MonthlyCountByDay3()
                 new Period(new CalDateTime(1997, 12, 22, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1998, 1, 19, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1998, 2, 16, 9, 0, 0, _tzid), Duration.FromHours(1))
-            },
-            new[]
-            {
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern"
             }
         );
     }
@@ -882,8 +692,8 @@ public void ByMonthDay1()
         var iCal = Calendar.Load(IcsFiles.ByMonthDay1)!;
         EventOccurrenceTest(
             iCal,
-            new CalDateTime(1996, 1, 1),
-            new CalDateTime(1998, 3, 1),
+            new CalDateTime(1996, 1, 1).ToTimeZone(_tzid),
+            new CalDateTime(1998, 3, 1).ToTimeZone(_tzid),
             new[]
             {
                 new Period(new CalDateTime(1997, 9, 28, 9, 0, 0, _tzid), Duration.FromHours(1)),
@@ -892,15 +702,6 @@ public void ByMonthDay1()
                 new Period(new CalDateTime(1997, 12, 29, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1998, 1, 29, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1998, 2, 26, 9, 0, 0, _tzid), Duration.FromHours(1))
-            },
-            new[]
-            {
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern"
             }
         );
     }
@@ -929,19 +730,6 @@ public void MonthlyCountByMonthDay1()
                 new Period(new CalDateTime(1997, 12, 15, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1998, 1, 2, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1998, 1, 15, 9, 0, 0, _tzid), Duration.FromHours(1))
-            },
-            new[]
-            {
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern"
             }
         );
     }
@@ -969,19 +757,6 @@ public void MonthlyCountByMonthDay2()
                 new Period(new CalDateTime(1998, 1, 1, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1998, 1, 31, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1998, 2, 1, 9, 0, 0, _tzid), Duration.FromHours(1))
-            },
-            new[]
-            {
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern"
             }
         );
     }
@@ -1009,19 +784,6 @@ public void MonthlyCountByMonthDay3()
                 new Period(new CalDateTime(1999, 3, 11, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1999, 3, 12, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1999, 3, 13, 9, 0, 0, _tzid), Duration.FromHours(1))
-            },
-            new[]
-            {
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern"
             }
         );
     }
@@ -1057,27 +819,6 @@ public void MonthlyByDay1()
                 new Period(new CalDateTime(1998, 3, 17, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1998, 3, 24, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1998, 3, 31, 9, 0, 0, _tzid), Duration.FromHours(1))
-            },
-            new[]
-            {
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern"
             }
         );
     }
@@ -1105,8 +846,7 @@ public void YearlyByMonth1()
                 new Period(new CalDateTime(2000, 7, 10, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(2001, 6, 10, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(2001, 7, 10, 9, 0, 0, _tzid), Duration.FromHours(1))
-            },
-            null
+            }
         );
     }
 
@@ -1133,8 +873,7 @@ public void YearlyCountByMonth1()
                 new Period(new CalDateTime(2003, 1, 10, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(2003, 2, 10, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(2003, 3, 10, 9, 0, 0, _tzid), Duration.FromHours(1))
-            },
-            null
+            }
         );
     }
 
@@ -1161,19 +900,6 @@ public void YearlyCountByYearDay1()
                 new Period(new CalDateTime(2003, 4, 10, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(2003, 7, 19, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(2006, 1, 1, 9, 0, 0, _tzid), Duration.FromHours(1))
-            },
-            new[]
-            {
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern"
             }
         );
     }
@@ -1194,8 +920,7 @@ public void YearlyByDay1()
                 new Period(new CalDateTime(1997, 5, 19, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1998, 5, 18, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1999, 5, 17, 9, 0, 0, _tzid), Duration.FromHours(1))
-            },
-            null
+            }
         );
     }
 
@@ -1212,8 +937,8 @@ public void WeekNoOrderingShouldNotMatter()
         var rpe2 = new RecurrencePatternEvaluator(new RecurrencePattern(
             "FREQ=YEARLY;WKST=MO;BYDAY=MO;BYWEEKNO=53,51,49,47,45,43,41,39,37,35,33,31,29,27,25,23,21,19,17,15,13,11,9,7,5,3,1"));
 
-        var recurringPeriods1 = rpe1.Evaluate(new CalDateTime(start), start, null).TakeWhileBefore(end).ToList();
-        var recurringPeriods2 = rpe2.Evaluate(new CalDateTime(start), start, null).TakeWhileBefore(end).ToList();
+        var recurringPeriods1 = rpe1.Evaluate(start, start, null).TakeWhileBefore(end).ToList();
+        var recurringPeriods2 = rpe2.Evaluate(start, start, null).TakeWhileBefore(end).ToList();
 
         Assert.That(recurringPeriods2, Has.Count.EqualTo(recurringPeriods1.Count));
     }
@@ -1234,8 +959,7 @@ public void YearlyByWeekNo1()
                 new Period(new CalDateTime(1997, 5, 12, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1998, 5, 11, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1999, 5, 17, 9, 0, 0, _tzid), Duration.FromHours(1))
-            },
-            null
+            }
         );
     }
 
@@ -1260,8 +984,7 @@ public void YearlyByWeekNo2()
                 new Period(new CalDateTime(1997, 5, 12, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1998, 5, 11, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1999, 5, 17, 9, 0, 0, _tzid), Duration.FromHours(1))
-            },
-            null
+            }
         );
     }
 
@@ -1284,8 +1007,7 @@ public void YearlyByWeekNo3()
             {
                 new Period(new CalDateTime(2002, 1, 1, 10, 0, 0, _tzid), Duration.FromMinutes(30)),
                 new Period(new CalDateTime(2002, 12, 31, 10, 0, 0, _tzid), Duration.FromMinutes(30))
-            },
-            null
+            }
         );
     }
 
@@ -1326,8 +1048,7 @@ public void YearlyByWeekNo4()
                 new Period(new CalDateTime(1999, 5, 21, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1999, 5, 22, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1999, 5, 23, 9, 0, 0, _tzid), Duration.FromHours(1))
-            },
-            null
+            }
         );
     }
 
@@ -1362,8 +1083,7 @@ public void YearlyByWeekNo5()
                 new Period(new CalDateTime(2003, 1, 3, 10, 0, 0, _tzid), Duration.FromMinutes(30)),
                 new Period(new CalDateTime(2003, 1, 4, 10, 0, 0, _tzid), Duration.FromMinutes(30)),
                 new Period(new CalDateTime(2003, 1, 5, 10, 0, 0, _tzid), Duration.FromMinutes(30))
-            },
-            null
+            }
         );
     }
 
@@ -1391,8 +1111,7 @@ public void YearlyByMonth2()
                 new Period(new CalDateTime(1999, 3, 11, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1999, 3, 18, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1999, 3, 25, 9, 0, 0, _tzid), Duration.FromHours(1))
-            },
-            null
+            }
         );
     }
 
@@ -1448,8 +1167,7 @@ public void YearlyByMonth3()
                 new Period(new CalDateTime(1999, 8, 12, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1999, 8, 19, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1999, 8, 26, 9, 0, 0, _tzid), Duration.FromHours(1))
-            },
-            null
+            }
         );
     }
 
@@ -1473,14 +1191,6 @@ public void MonthlyByMonthDay1()
                 new Period(new CalDateTime(1998, 11, 13, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1999, 8, 13, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(2000, 10, 13, 9, 0, 0, _tzid), Duration.FromHours(1))
-            },
-            new[]
-            {
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern"
             }
         );
     }
@@ -1508,19 +1218,6 @@ public void MonthlyByMonthDay2()
                 new Period(new CalDateTime(1998, 4, 11, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1998, 5, 9, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1998, 6, 13, 9, 0, 0, _tzid), Duration.FromHours(1))
-            },
-            new[]
-            {
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern"
             }
         );
     }
@@ -1541,8 +1238,7 @@ public void YearlyByMonthDay1()
                 new Period(new CalDateTime(1996, 11, 5, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(2000, 11, 7, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(2004, 11, 2, 9, 0, 0, _tzid), Duration.FromHours(1))
-            },
-            null
+            }
         );
     }
 
@@ -1562,12 +1258,6 @@ public void MonthlyBySetPos1()
                 new Period(new CalDateTime(1997, 9, 4, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1997, 10, 7, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1997, 11, 6, 9, 0, 0, _tzid), Duration.FromHours(1))
-            },
-            new[]
-            {
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern"
             }
         );
     }
@@ -1592,16 +1282,6 @@ public void MonthlyBySetPos2()
                 new Period(new CalDateTime(1998, 1, 29, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1998, 2, 26, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1998, 3, 30, 9, 0, 0, _tzid), Duration.FromHours(1))
-            },
-            new[]
-            {
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern",
-                "US-Eastern"
             }
         );
     }
@@ -1624,9 +1304,8 @@ public void HourlyUntil1()
                 new Period(new CalDateTime(1997, 9, 2, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1997, 9, 2, 12, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1997, 9, 2, 15, 0, 0, _tzid), Duration.FromHours(1)),
-                new Period(new CalDateTime(1997, 9, 2, 18, 0, 0, _tzid), Duration.FromHours(1))
-            },
-            timeZones: null
+                new Period(new CalDateTime(1997, 9, 2, 18, 0, 0, _tzid), Duration.FromHours(1)),
+            }
         );
     }
 
@@ -1649,8 +1328,7 @@ public void MinutelyCount1()
                 new Period(new CalDateTime(1997, 9, 2, 9, 45, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1997, 9, 2, 10, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1997, 9, 2, 10, 15, 0, _tzid), Duration.FromHours(1))
-            },
-            null
+            }
         );
     }
 
@@ -1671,8 +1349,7 @@ public void MinutelyCount2()
                 new Period(new CalDateTime(1997, 9, 2, 10, 30, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1997, 9, 2, 12, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1997, 9, 2, 13, 30, 0, _tzid), Duration.FromHours(1))
-            },
-            null
+            }
         );
     }
 
@@ -1699,8 +1376,7 @@ public void MinutelyCount3()
                 new Period(new CalDateTime(2010, 8, 27, 11, 7, 0, _tzid), Duration.FromMinutes(3)),
                 new Period(new CalDateTime(2010, 8, 27, 11, 8, 0, _tzid), Duration.FromMinutes(3)),
                 new Period(new CalDateTime(2010, 8, 27, 11, 9, 0, _tzid), Duration.FromMinutes(3))
-            },
-            null
+            }
         );
     }
 
@@ -1727,8 +1403,7 @@ public void MinutelyCount4()
                 new Period(new CalDateTime(2010, 8, 27, 11, 49, 0, _tzid), Duration.FromMinutes(3)),
                 new Period(new CalDateTime(2010, 8, 27, 11, 56, 0, _tzid), Duration.FromMinutes(3)),
                 new Period(new CalDateTime(2010, 8, 27, 12, 3, 0, _tzid), Duration.FromMinutes(3))
-            },
-            null
+            }
         );
     }
 
@@ -1793,8 +1468,7 @@ public void DailyByHourMinute1()
                 new Period(new CalDateTime(1997, 9, 3, 16, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1997, 9, 3, 16, 20, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1997, 9, 3, 16, 40, 0, _tzid), Duration.FromHours(1))
-            },
-            null
+            }
         );
     }
 
@@ -1840,8 +1514,7 @@ public void WeeklyCountWkst3()
                 new Period(new CalDateTime(1997, 8, 10, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1997, 8, 19, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1997, 8, 24, 9, 0, 0, _tzid), Duration.FromHours(1))
-            },
-            null
+            }
         );
     }
 
@@ -1863,8 +1536,7 @@ public void WeeklyCountWkst4()
                 new Period(new CalDateTime(1997, 8, 17, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1997, 8, 19, 9, 0, 0, _tzid), Duration.FromHours(1)),
                 new Period(new CalDateTime(1997, 8, 31, 9, 0, 0, _tzid), Duration.FromHours(1))
-            },
-            null
+            }
         );
     }
 
@@ -1894,8 +1566,7 @@ public void Bug1741093()
                 new Period(new CalDateTime(2007, 7, 20, 8, 0, 0, _tzid), Duration.FromHours(9)),
                 new Period(new CalDateTime(2007, 7, 30, 8, 0, 0, _tzid), Duration.FromHours(9)),
                 new Period(new CalDateTime(2007, 7, 31, 8, 0, 0, _tzid), Duration.FromHours(9))
-            },
-            null
+            }
         );
     }
 
@@ -1904,16 +1575,20 @@ public void Secondly_DefinedNumberOfOccurrences_ShouldSucceed()
     {
         var iCal = Calendar.Load(IcsFiles.Secondly1)!;
 
-        var start = new CalDateTime(2007, 6, 21, 8, 0, 0, _tzid);
-        var end = new CalDateTime(2007, 6, 21, 8, 1, 0, _tzid); // End period is exclusive, not inclusive.
+        var tz = DateUtil.GetZone(_tzid);
+        var start = new LocalDateTime(2007, 6, 21, 8, 0).InZoneStrictly(tz);
+        var end = new LocalDateTime(2007, 6, 21, 8, 1).InZoneStrictly(tz);
 
         var periods = new List<Period>();
-        for (var dt = start; dt.LessThan(end); dt = (CalDateTime) dt.AddSeconds(1))
+        for (var dt = start; dt.ToInstant() < end.ToInstant(); dt = dt.PlusSeconds(1))
         {
             periods.Add(new Period(new CalDateTime(dt), Duration.FromHours(9)));
         }
 
-        EventOccurrenceTest(iCal, start, end, periods.ToArray(), null);
+        var calStart = new CalDateTime(start);
+        var calEnd = new CalDateTime(end); // End period is exclusive, not inclusive.
+
+        EventOccurrenceTest(iCal, calStart, calEnd, periods.ToArray());
     }
 
     [Test, Category("Recurrence")]
@@ -1921,16 +1596,20 @@ public void Minutely_DefinedNumberOfOccurrences_ShouldSucceed()
     {
         var iCal = Calendar.Load(IcsFiles.Minutely1)!;
 
-        var start = new CalDateTime(2007, 6, 21, 8, 0, 0, _tzid);
-        var end = new CalDateTime(2007, 6, 21, 12, 0, 1, _tzid); // End period is exclusive, not inclusive.
+        var tz = DateUtil.GetZone(_tzid);
+        var start = new LocalDateTime(2007, 6, 21, 8, 0, 0).InZoneStrictly(tz);
+        var end = new LocalDateTime(2007, 6, 21, 12, 0, 1).InZoneStrictly(tz); // End period is exclusive, not inclusive.
 
         var periods = new List<Period>();
-        for (var dt = start; dt.LessThan(end); dt = (CalDateTime) dt.AddMinutes(1))
+        for (var dt = start; dt.ToInstant() < end.ToInstant(); dt = dt.PlusMinutes(1))
         {
             periods.Add(new Period(new CalDateTime(dt), Duration.FromHours(9)));
         }
 
-        EventOccurrenceTest(iCal, start, end, periods.ToArray(), null);
+        var calStart = new CalDateTime(start);
+        var calEnd = new CalDateTime(end);
+
+        EventOccurrenceTest(iCal, calStart, calEnd, periods.ToArray());
     }
 
     [Test, Category("Recurrence")]
@@ -1938,16 +1617,20 @@ public void Hourly_DefinedNumberOfOccurrences_ShouldSucceed()
     {
         var iCal = Calendar.Load(IcsFiles.Hourly1)!;
 
-        var start = new CalDateTime(2007, 6, 21, 8, 0, 0, _tzid);
-        var end = new CalDateTime(2007, 6, 25, 8, 0, 1, _tzid); // End period is exclusive, not inclusive.
+        var tz = DateUtil.GetZone(_tzid);
+        var start = new LocalDateTime(2007, 6, 21, 8, 0, 0).InZoneStrictly(tz);
+        var end = new LocalDateTime(2007, 6, 25, 8, 0, 1).InZoneStrictly(tz); // End period is exclusive, not inclusive.
 
         var periods = new List<Period>();
-        for (var dt = start; dt.LessThan(end); dt = (CalDateTime) dt.AddHours(1))
+        for (var dt = start; dt.ToInstant() < end.ToInstant(); dt = dt.PlusHours(1))
         {
             periods.Add(new Period(new CalDateTime(dt), Duration.FromHours(9)));
         }
 
-        EventOccurrenceTest(iCal, start, end, periods.ToArray(), null);
+        var calStart = new CalDateTime(start);
+        var calEnd = new CalDateTime(end);
+
+        EventOccurrenceTest(iCal, calStart, calEnd, periods.ToArray());
     }
 
     /// <summary>
@@ -1965,8 +1648,7 @@ public void MonthlyInterval1()
             {
                 new Period(new CalDateTime(2008, 2, 11, 7, 0, 0, _tzid), Duration.FromHours(24)),
                 new Period(new CalDateTime(2008, 2, 12, 7, 0, 0, _tzid), Duration.FromHours(24))
-            },
-            null
+            }
         );
     }
 
@@ -1988,8 +1670,7 @@ public void YearlyInterval1()
                 new Period(new CalDateTime(2007, 4, 10, 7, 0, 0, _tzid), Duration.FromHours(24)),
                 new Period(new CalDateTime(2009, 4, 13, 7, 0, 0, _tzid), Duration.FromHours(24)),
                 new Period(new CalDateTime(2009, 4, 14, 7, 0, 0, _tzid), Duration.FromHours(24))
-            ],
-            null
+            ]
         );
     }
 
@@ -2008,8 +1689,7 @@ public void DailyInterval1()
             {
                 new Period(new CalDateTime(2007, 4, 12, 7, 0, 0, _tzid), Duration.FromHours(24)),
                 new Period(new CalDateTime(2007, 4, 15, 7, 0, 0, _tzid), Duration.FromHours(24))
-            },
-            null
+            }
         );
     }
 
@@ -2033,8 +1713,7 @@ public void HourlyInterval1()
                 new Period(new CalDateTime(2007, 4, 9, 7, 0, 0, _tzid), Duration.FromHours(24)),
                 new Period(new CalDateTime(2007, 4, 10, 1, 0, 0, _tzid), Duration.FromHours(24)),
                 new Period(new CalDateTime(2007, 4, 10, 19, 0, 0, _tzid), Duration.FromHours(24))
-            },
-            null
+            }
         );
     }
 
@@ -2063,8 +1742,7 @@ public void YearlyBySetPos1()
                 new Period(new CalDateTime(2016, 9, 25, 5, 30, 0), Duration.FromMinutes(30)),
                 new Period(new CalDateTime(2017, 9, 30, 5, 30, 0), Duration.FromMinutes(30)),
                 new Period(new CalDateTime(2018, 9, 30, 5, 30, 0), Duration.FromMinutes(30))
-            },
-            null
+            }
         );
     }
 
@@ -2083,8 +1761,7 @@ public void Empty1()
             new[]
             {
                 new Period(new CalDateTime(2009, 9, 27, 5, 30, 0), new Duration(days: 3, minutes: 30))
-            },
-            null
+            }
         );
     }
 
@@ -2112,8 +1789,7 @@ public void HourlyInterval2()
                 new Period(new CalDateTime(2007, 4, 10, 15, 0, 0), Duration.FromDays(1)),
                 new Period(new CalDateTime(2007, 4, 10, 19, 0, 0), Duration.FromDays(1)),
                 new Period(new CalDateTime(2007, 4, 10, 23, 0, 0), Duration.FromDays(1))
-            },
-            null
+            }
         );
     }
 
@@ -2141,8 +1817,7 @@ public void MinutelyInterval1()
                 new Period(new CalDateTime(2007, 4, 9, 11, 0, 0), Duration.FromDays(1)),
                 new Period(new CalDateTime(2007, 4, 9, 11, 30, 0), Duration.FromDays(1)),
                 new Period(new CalDateTime(2007, 4, 9, 12, 0, 0), Duration.FromDays(1))
-            },
-            null
+            }
         );
     }
 
@@ -2169,8 +1844,7 @@ public void DailyInterval2()
                 new Period(new CalDateTime(2007, 4, 23, 7, 0, 0), Duration.FromDays(1)),
                 new Period(new CalDateTime(2007, 4, 25, 7, 0, 0), Duration.FromDays(1)),
                 new Period(new CalDateTime(2007, 4, 27, 7, 0, 0), Duration.FromDays(1))
-            },
-            null
+            }
         );
     }
 
@@ -2193,8 +1867,7 @@ public void DailyByDay1()
                 new Period(new CalDateTime(2007, 9, 20, 7, 0, 0), Duration.FromHours(1)),
                 new Period(new CalDateTime(2007, 9, 24, 7, 0, 0), Duration.FromHours(1)),
                 new Period(new CalDateTime(2007, 9, 27, 7, 0, 0), Duration.FromHours(1))
-            },
-            null
+            }
         );
     }
 
@@ -2221,8 +1894,7 @@ public void WeeklyWeekStartsLastYear()
                 new Period(new CalDateTime(2012, 1, 11, 7, 0, 0), Duration.Zero),
                 new Period(new CalDateTime(2012, 1, 12, 7, 0, 0), Duration.Zero),
                 new Period(new CalDateTime(2012, 1, 13, 7, 0, 0), Duration.Zero)
-            },
-            null
+            }
         );
     }
 
@@ -2248,8 +1920,7 @@ public void WeeklyInterval1()
                 new Period(new CalDateTime(2007, 12, 3, 7, 0, 0), Duration.FromHours(1)),
                 new Period(new CalDateTime(2007, 12, 17, 7, 0, 0), Duration.FromHours(1)),
                 new Period(new CalDateTime(2007, 12, 31, 7, 0, 0), Duration.FromHours(1))
-            },
-            null
+            }
         );
     }
 
@@ -2279,8 +1950,7 @@ public void Monthly1()
                 new Period(new CalDateTime(2008, 7, 10, 7, 0, 0), Duration.FromHours(1)),
                 new Period(new CalDateTime(2008, 8, 10, 7, 0, 0), Duration.FromHours(1)),
                 new Period(new CalDateTime(2008, 9, 10, 7, 0, 0), Duration.FromHours(1))
-            },
-            null
+            }
         );
     }
 
@@ -2311,8 +1981,7 @@ public void Yearly1()
                 new Period(new CalDateTime(2018, 9, 10, 7, 0, 0), Duration.FromHours(1)),
                 new Period(new CalDateTime(2019, 9, 10, 7, 0, 0), Duration.FromHours(1)),
                 new Period(new CalDateTime(2020, 9, 10, 7, 0, 0), Duration.FromHours(1))
-            },
-            null
+            }
         );
     }
 
@@ -2342,34 +2011,31 @@ public void Bug2912657()
                 new Period(new CalDateTime(2009, 12, 9, 2, 00, 00, localTzid), Duration.FromMinutes(30)),
                 new Period(new CalDateTime(2009, 12, 10, 2, 00, 00, localTzid), Duration.FromMinutes(30))
             },
-            null,
             0
         );
 
         // Weekly with UNTIL value
         EventOccurrenceTest(
             iCal,
-            new CalDateTime(2009, 12, 4),
-            new CalDateTime(2009, 12, 10),
+            new CalDateTime(2009, 12, 4).ToTimeZone(localTzid),
+            new CalDateTime(2009, 12, 10).ToTimeZone(localTzid),
             new[]
             {
                 new Period(new CalDateTime(2009, 12, 4, 2, 00, 00, localTzid), Duration.FromMinutes(30))
             },
-            null,
             1
         );
 
         // Weekly with COUNT=2
         EventOccurrenceTest(
             iCal,
-            new CalDateTime(2009, 12, 4),
-            new CalDateTime(2009, 12, 12),
+            new CalDateTime(2009, 12, 4).ToTimeZone(localTzid),
+            new CalDateTime(2009, 12, 12).ToTimeZone(localTzid),
             new[]
             {
                 new Period(new CalDateTime(2009, 12, 4, 2, 00, 00, localTzid), Duration.FromMinutes(30)),
                 new Period(new CalDateTime(2009, 12, 11, 2, 00, 00, localTzid), Duration.FromMinutes(30))
             },
-            null,
             2
         );
     }
@@ -2395,7 +2061,6 @@ public void Bug2916581()
                 new Period(new CalDateTime(2009, 12, 25, 11, 00, 00, localTzid), Duration.FromMinutes(30)),
                 new Period(new CalDateTime(2010, 1, 1, 11, 00, 00, localTzid), Duration.FromMinutes(30))
             },
-            null,
             0
         );
 
@@ -2409,7 +2074,6 @@ public void Bug2916581()
                 new Period(new CalDateTime(2009, 12, 26, 11, 00, 00, localTzid), Duration.FromMinutes(30)),
                 new Period(new CalDateTime(2010, 1, 2, 11, 00, 00, localTzid), Duration.FromMinutes(30))
             },
-            null,
             1
         );
     }
@@ -2439,7 +2103,6 @@ public void Bug2959692()
                 new Period(new CalDateTime(2008, 3, 13, 17, 00, 00, localTzid), Duration.FromMinutes(30)),
                 new Period(new CalDateTime(2008, 3, 27, 17, 00, 00, localTzid), Duration.FromMinutes(30))
             },
-            null,
             0
         );
     }
@@ -2468,7 +2131,6 @@ public void Bug2966236()
                 new Period(new CalDateTime(2010, 2, 16, 8, 00, 00, localTzid), Duration.FromMinutes(30)),
                 new Period(new CalDateTime(2010, 2, 23, 8, 00, 00, localTzid), Duration.FromMinutes(30))
             },
-            null,
             0
         );
 
@@ -2483,7 +2145,6 @@ public void Bug2966236()
                 new Period(new CalDateTime(2010, 2, 16, 8, 00, 00, localTzid), Duration.FromMinutes(30)),
                 new Period(new CalDateTime(2010, 2, 23, 8, 00, 00, localTzid), Duration.FromMinutes(30))
             },
-            null,
             0
         );
     }
@@ -2504,7 +2165,6 @@ public void Bug3007244()
             fromDate: new CalDateTime(2010, 7, 18),
             toDate: new CalDateTime(2010, 7, 26),
             expectedPeriods: new[] { new Period(new CalDateTime(2010, 05, 23), Duration.FromDays(102)) },
-            timeZones: null,
             eventIndex: 0
         );
 
@@ -2514,7 +2174,6 @@ public void Bug3007244()
             fromDate: new CalDateTime(2011, 7, 18),
             toDate: new CalDateTime(2011, 7, 26),
             expectedPeriods: new[] { new Period(new CalDateTime(2011, 05, 23), Duration.FromDays(102)) },
-            timeZones: null,
             eventIndex: 0
         );
     }
@@ -2604,7 +2263,15 @@ public void DurationOfRecurrencesOverDst(string dtStart, string dtEnd, string? d
         {
             var p = expectedPeriods[index];
             var newStart = p.StartTime.ToTimeZone(start!.TzId);
-            expectedPeriods[index] = Period.Create(newStart, duration: p.EffectiveDuration);
+
+            if (p.EndTime is not null)
+            {
+                expectedPeriods[index] = new Period(newStart, p.EndTime.ToTimeZone(start!.TzId));
+            }
+            else
+            {
+                expectedPeriods[index] = new Period(newStart, p.Duration!.Value);
+            }
         }
 
         // date only cannot have a time zone
@@ -2613,8 +2280,10 @@ public void DurationOfRecurrencesOverDst(string dtStart, string dtEnd, string? d
             fromDate: null,
             toDate: null,
             expectedPeriods: expectedPeriods,
-            timeZones: null,
-            eventIndex: 0
+            eventIndex: 0,
+            // The above tests use nominal values as expected
+            // results, so the time zone must be set.
+            timeZone: "Europe/Vienna"
         );
     }
 
@@ -2628,10 +2297,10 @@ public void BugByWeekNoNotWorking()
         var end = new CalDateTime(2019, 12, 31);
         var rpe = new RecurrencePatternEvaluator(new RecurrencePattern("FREQ=WEEKLY;BYDAY=MO;BYWEEKNO=2"));
 
-        var recurringPeriods = rpe.Evaluate(start, start, default).TakeWhileBefore(end).ToList();
+        var recurringPeriods = rpe.Evaluate(start, start.ToZonedDateTime(_tzid), default).TakeWhileBefore(end).ToList();
 
         Assert.That(recurringPeriods, Has.Count.EqualTo(1));
-        Assert.That(recurringPeriods.First().StartTime, Is.EqualTo(new CalDateTime(2019, 1, 7)));
+        Assert.That(recurringPeriods.First().Start, Is.EqualTo(new CalDateTime(2019, 1, 7).ToZonedDateTime(_tzid)));
     }
 
     /// <summary>
@@ -2644,15 +2313,15 @@ public void BugByMonthWhileFreqIsWeekly()
         var end = new CalDateTime(2020, 12, 31);
         var rpe = new RecurrencePatternEvaluator(new RecurrencePattern("FREQ=WEEKLY;BYDAY=MO;BYMONTH=1"));
 
-        var recurringPeriods = rpe.Evaluate(start, start, default).TakeWhileBefore(end).ToList();
+        var recurringPeriods = rpe.Evaluate(start, start.ToZonedDateTime(_tzid), default).TakeWhileBefore(end).ToList();
 
         Assert.That(recurringPeriods, Has.Count.EqualTo(4));
         Assert.Multiple(() =>
         {
-            Assert.That(recurringPeriods[0].StartTime, Is.EqualTo(new CalDateTime(2020, 1, 6)));
-            Assert.That(recurringPeriods[1].StartTime, Is.EqualTo(new CalDateTime(2020, 1, 13)));
-            Assert.That(recurringPeriods[2].StartTime, Is.EqualTo(new CalDateTime(2020, 1, 20)));
-            Assert.That(recurringPeriods[3].StartTime, Is.EqualTo(new CalDateTime(2020, 1, 27)));
+            Assert.That(recurringPeriods[0].Start, Is.EqualTo(new CalDateTime(2020, 1, 6).ToZonedDateTime(_tzid)));
+            Assert.That(recurringPeriods[1].Start, Is.EqualTo(new CalDateTime(2020, 1, 13).ToZonedDateTime(_tzid)));
+            Assert.That(recurringPeriods[2].Start, Is.EqualTo(new CalDateTime(2020, 1, 20).ToZonedDateTime(_tzid)));
+            Assert.That(recurringPeriods[3].Start, Is.EqualTo(new CalDateTime(2020, 1, 27).ToZonedDateTime(_tzid)));
         });
     }
 
@@ -2688,15 +2357,15 @@ public void BugByMonthWhileFreqIsMonthly()
         var end = new CalDateTime(2020, 12, 31);
         var rpe = new RecurrencePatternEvaluator(new RecurrencePattern("FREQ=MONTHLY;BYDAY=MO;BYMONTH=1"));
 
-        var recurringPeriods = rpe.Evaluate(start, start, default).TakeWhileBefore(end).ToList();
+        var recurringPeriods = rpe.Evaluate(start, start.ToZonedDateTime(_tzid), default).TakeWhileBefore(end).ToList();
 
         Assert.That(recurringPeriods, Has.Count.EqualTo(4));
         Assert.Multiple(() =>
         {
-            Assert.That(recurringPeriods[0].StartTime, Is.EqualTo(new CalDateTime(2020, 1, 6)));
-            Assert.That(recurringPeriods[1].StartTime, Is.EqualTo(new CalDateTime(2020, 1, 13)));
-            Assert.That(recurringPeriods[2].StartTime, Is.EqualTo(new CalDateTime(2020, 1, 20)));
-            Assert.That(recurringPeriods[3].StartTime, Is.EqualTo(new CalDateTime(2020, 1, 27)));
+            Assert.That(recurringPeriods[0].Start, Is.EqualTo(new CalDateTime(2020, 1, 6).ToZonedDateTime(_tzid)));
+            Assert.That(recurringPeriods[1].Start, Is.EqualTo(new CalDateTime(2020, 1, 13).ToZonedDateTime(_tzid)));
+            Assert.That(recurringPeriods[2].Start, Is.EqualTo(new CalDateTime(2020, 1, 20).ToZonedDateTime(_tzid)));
+            Assert.That(recurringPeriods[3].Start, Is.EqualTo(new CalDateTime(2020, 1, 27).ToZonedDateTime(_tzid)));
         });
     }
 
@@ -2712,12 +2381,12 @@ public void Bug3119920()
         var serializer = new RecurrencePatternSerializer();
         var rp = (RecurrencePattern) serializer.Deserialize(sr)!;
         var rpe = new RecurrencePatternEvaluator(rp);
-        var recurringPeriods = rpe.Evaluate(start, start, null)
+        var recurringPeriods = rpe.Evaluate(start, start.ToZonedDateTime(_tzid), null)
             .TakeWhileBefore(rp.Until!).ToList();
 
         var period = recurringPeriods.ElementAt(recurringPeriods.Count - 1);
 
-        Assert.That(period.StartTime, Is.EqualTo(new CalDateTime(2025, 11, 24, 9, 0, 0)));
+        Assert.That(period.Start, Is.EqualTo(new CalDateTime(2025, 11, 24, 9, 0, 0).ToZonedDateTime(_tzid)));
     }
 
     /// <summary>
@@ -2788,23 +2457,24 @@ public void Issue432()
         //Testing on both the first day and the next, results used to be different
         for (var i = 0; i <= 1; i++)
         {
-            var checkTime = new CalDateTime(2019, 01, 04, 08, 00, 00, CalDateTime.UtcTzId);
-            checkTime = checkTime.AddDays(i);
+            var checkTime = new CalDateTime(2019, 01, 04, 08, 00, 00).ToZonedDateTime("UTC");
+            checkTime = checkTime.LocalDateTime.PlusDays(i).InZoneLeniently(checkTime.Zone);
             //Valid asking for the exact moment
-            var occurrences = vEvent.GetOccurrences(checkTime).TakeWhile(p => p.Period.StartTime == checkTime).ToList();
+            var occurrences = vEvent.GetOccurrences(checkTime).TakeWhile(p => p.Start == checkTime).ToList();
             Assert.That(occurrences, Has.Count.EqualTo(1));
 
             //Valid if asking for a range starting at the same moment
-            occurrences = vEvent.GetOccurrences(checkTime).TakeWhileBefore(checkTime.AddSeconds(1)).ToList();
+            occurrences = vEvent.GetOccurrences(checkTime).TakeWhileBefore(checkTime.PlusSeconds(1).ToInstant()).ToList();
             Assert.That(occurrences, Has.Count.EqualTo(1));
 
             //Valid if asking for a range starting before and ending after
-            occurrences = vEvent.GetOccurrences(checkTime.AddSeconds(-1)).TakeWhileBefore(checkTime.AddSeconds(1))
+            occurrences = vEvent.GetOccurrences(checkTime.PlusSeconds(-1))
+                .TakeWhileBefore(checkTime.PlusSeconds(1).ToInstant())
                 .ToList();
             Assert.That(occurrences, Has.Count.EqualTo(1));
 
             //Not valid if asking for a range starting before but ending at the same moment
-            occurrences = vEvent.GetOccurrences(checkTime.AddSeconds(-1)).TakeWhileBefore(checkTime).ToList();
+            occurrences = vEvent.GetOccurrences(checkTime.PlusSeconds(-1)).TakeWhileBefore(checkTime.ToInstant()).ToList();
             Assert.That(occurrences.Count, Is.EqualTo(0));
         }
     }
@@ -2864,7 +2534,7 @@ public void UsHolidays()
         };
 
         var occurrences = iCal.GetOccurrences(
-                new CalDateTime(2006, 1, 1))
+            new CalDateTime(2006, 1, 1).ToZonedDateTime("US/Eastern"))
             .TakeWhileBefore(new CalDateTime(2006, 12, 31))
             .ToList();
 
@@ -2877,7 +2547,7 @@ public void UsHolidays()
             {
                 Assert.That(items.ContainsKey(evt.Summary!), Is.True,
                     "Holiday text '" + evt.Summary + "' did not match known holidays.");
-                Assert.That(o.Period.StartTime, Is.EqualTo(items[evt.Summary!]),
+                Assert.That(o.Start, Is.EqualTo(items[evt.Summary!].ToZonedDateTime(_tzid)),
                     "Date/time of holiday '" + evt.Summary + "' did not match.");
             });
         }
@@ -2907,18 +2577,20 @@ public void Evaluate1(string freq, int secsPerInterval, bool hasTime)
         // ical.net handles the case by pretending DTSTART has the time set to midnight.
         evt.RecurrenceRules.Add(new RecurrencePattern($"FREQ={freq};INTERVAL=10;COUNT=5"));
 
-        var occurrences = evt.GetOccurrences(evt.Start.AddDays(-1)).TakeWhileBefore(evt.Start.AddDays(100))
+        var occurrences = evt.GetOccurrences(evt.Start.ToZonedDateTime().PlusHours(-24))
+            .TakeWhileBefore(evt.Start.AddDays(100))
             .ToList();
 
-        var startDates = occurrences.Select(x => x.Period.StartTime.Value).ToList();
+        var startDates = occurrences.Select(x => x.Start.ToInstant()).ToList();
 
         var expectedStartDates = Enumerable.Range(0, 5)
             .Select(i => DateTime.UtcNow.Date.AddSeconds(i * secsPerInterval * 10))
+            .Select(x => x.ToInstant())
             .ToList();
 
         Assert.Multiple(() =>
         {
-            Assert.That(occurrences.Select(x => x.Period.StartTime.HasTime == hasTime), Is.All.True);
+            Assert.That(occurrences.Select(x => x.End.ToInstant() > x.Start.ToInstant()), Is.All.True);
             Assert.That(startDates, Is.EqualTo(expectedStartDates));
         });
     }
@@ -2930,11 +2602,9 @@ public void RecurrencePattern1()
         // However, this does make a good test to ensure they behave as they should.
         var pattern = new RecurrencePattern("FREQ=SECONDLY;INTERVAL=10");
 
-        var us = new CultureInfo("en-US");
-
-        var startDate = new CalDateTime(DateTime.Parse("3/30/08 11:59:40 PM", us));
-        var fromDate = new CalDateTime(DateTime.Parse("3/30/08 11:59:40 PM", us));
-        var toDate = new CalDateTime(DateTime.Parse("3/31/08 12:00:11 AM", us));
+        var startDate = new CalDateTime(2008, 3, 30, 23, 59, 40);
+        var fromDate = startDate.ToZonedDateTime(_tzid);
+        var toDate = new CalDateTime(2008, 3, 31, 0, 0, 11);
 
         var evaluator = new RecurrencePatternEvaluator(pattern);
         var occurrences = evaluator.Evaluate(
@@ -2946,14 +2616,10 @@ public void RecurrencePattern1()
         Assert.That(occurrences, Has.Count.EqualTo(4));
         Assert.Multiple(() =>
         {
-            Assert.That(occurrences[0].StartTime,
-                Is.EqualTo(new CalDateTime(DateTime.Parse("03/30/08 11:59:40 PM", us))));
-            Assert.That(occurrences[1].StartTime,
-                Is.EqualTo(new CalDateTime(DateTime.Parse("03/30/08 11:59:50 PM", us))));
-            Assert.That(occurrences[2].StartTime,
-                Is.EqualTo(new CalDateTime(DateTime.Parse("03/31/08 12:00:00 AM", us))));
-            Assert.That(occurrences[3].StartTime,
-                Is.EqualTo(new CalDateTime(DateTime.Parse("03/31/08 12:00:10 AM", us))));
+            Assert.That(occurrences[0].Start, Is.EqualTo(new CalDateTime(2008, 3, 30, 23, 59, 40).ToZonedDateTime(_tzid)));
+            Assert.That(occurrences[1].Start, Is.EqualTo(new CalDateTime(2008, 3, 30, 23, 59, 50).ToZonedDateTime(_tzid)));
+            Assert.That(occurrences[2].Start, Is.EqualTo(new CalDateTime(2008, 3, 31, 00, 00, 00).ToZonedDateTime(_tzid)));
+            Assert.That(occurrences[3].Start, Is.EqualTo(new CalDateTime(2008, 3, 31, 00, 00, 10).ToZonedDateTime(_tzid)));
         });
     }
 
@@ -3088,16 +2754,16 @@ public void Test4()
         Assert.That(periods, Has.Count.EqualTo(10));
         Assert.Multiple(() =>
         {
-            Assert.That(periods[0].StartTime.Day, Is.EqualTo(2));
-            Assert.That(periods[1].StartTime.Day, Is.EqualTo(3));
-            Assert.That(periods[2].StartTime.Day, Is.EqualTo(9));
-            Assert.That(periods[3].StartTime.Day, Is.EqualTo(10));
-            Assert.That(periods[4].StartTime.Day, Is.EqualTo(16));
-            Assert.That(periods[5].StartTime.Day, Is.EqualTo(17));
-            Assert.That(periods[6].StartTime.Day, Is.EqualTo(23));
-            Assert.That(periods[7].StartTime.Day, Is.EqualTo(24));
-            Assert.That(periods[8].StartTime.Day, Is.EqualTo(30));
-            Assert.That(periods[9].StartTime.Day, Is.EqualTo(31));
+            Assert.That(periods[0].Start.Day, Is.EqualTo(2));
+            Assert.That(periods[1].Start.Day, Is.EqualTo(3));
+            Assert.That(periods[2].Start.Day, Is.EqualTo(9));
+            Assert.That(periods[3].Start.Day, Is.EqualTo(10));
+            Assert.That(periods[4].Start.Day, Is.EqualTo(16));
+            Assert.That(periods[5].Start.Day, Is.EqualTo(17));
+            Assert.That(periods[6].Start.Day, Is.EqualTo(23));
+            Assert.That(periods[7].Start.Day, Is.EqualTo(24));
+            Assert.That(periods[8].Start.Day, Is.EqualTo(30));
+            Assert.That(periods[9].Start.Day, Is.EqualTo(31));
         });
     }
 
@@ -3115,7 +2781,7 @@ public void Test4()
               END:VCALENDAR
               """, true)]
 
-    // y10k exceeded due to the event duration
+    // y10k exceeded due to the event duration. Start is valid, but End exceeds y10k.
     [TestCase("""
               BEGIN:VCALENDAR
               BEGIN:VEVENT
@@ -3124,7 +2790,7 @@ public void Test4()
               RRULE:FREQ=DAILY;BYHOUR=22,23;COUNT=2
               END:VEVENT
               END:VCALENDAR
-              """, false)]
+              """, true)]
 
     // Events are merged in different places than individual RRULES of a single event
     [TestCase("""
@@ -3140,7 +2806,7 @@ public void Test4()
     public void Recurrence_WithOutOfBoundsUtc_ShouldFailWithCorrectException(string ical, bool shouldThrow)
     {
         var cal = Calendar.Load(ical)!;
-        Assert.That(() => cal.GetOccurrences().ToList(),
+        Assert.That(() => cal.GetOccurrences(DateUtil.GetZone(_tzid)).ToList(),
             shouldThrow ? Throws.InstanceOf<EvaluationOutOfRangeException>() : Throws.Nothing);
     }
 
@@ -3194,25 +2860,24 @@ public void RDateShouldBeUnionedWithRecurrenceSet()
 
         var calendar = Calendar.Load(ical)!;
         var firstEvent = calendar.Events.First();
-        var startSearch = new CalDateTime(DateTime.Parse("2015-08-28T07:00:00", CultureInfo.InvariantCulture), _tzid);
-        var endSearch = new CalDateTime(DateTime.Parse("2016-08-28T07:00:00", CultureInfo.InvariantCulture).AddDays(7),
-            _tzid);
+        var startSearch = new CalDateTime(DateTime.Parse("2015-08-28T07:00:00", CultureInfo.InvariantCulture), _tzid)
+            .ToZonedDateTime();
+        var endSearch = new CalDateTime(DateTime.Parse("2016-08-28T07:00:00", CultureInfo.InvariantCulture).AddDays(7), _tzid)
+            .ToZonedDateTime()
+            .ToInstant();
 
         var occurrences = firstEvent.GetOccurrences(startSearch).TakeWhileBefore(endSearch)
             .Select(o => o.Period)
             .ToList();
 
-        var firstExpectedOccurrence =
-            new CalDateTime(DateTime.Parse("2016-08-29T08:00:00", CultureInfo.InvariantCulture), _tzid);
-        Assert.That(occurrences.First().StartTime, Is.EqualTo(firstExpectedOccurrence));
+        var firstExpectedOccurrence = new CalDateTime(DateTime.Parse("2016-08-29T08:00:00", CultureInfo.InvariantCulture), _tzid).ToZonedDateTime();
+        Assert.That(occurrences.First().Start, Is.EqualTo(firstExpectedOccurrence));
 
-        var firstExpectedRDate =
-            new CalDateTime(DateTime.Parse("2016-08-30T10:00:00", CultureInfo.InvariantCulture), _tzid);
-        Assert.That(occurrences[1].StartTime.Equals(firstExpectedRDate), Is.True);
+        var firstExpectedRDate = new CalDateTime(DateTime.Parse("2016-08-30T10:00:00", CultureInfo.InvariantCulture), _tzid).ToZonedDateTime();
+        Assert.That(occurrences[1].Start.Equals(firstExpectedRDate), Is.True);
 
-        var secondExpectedRDate =
-            new CalDateTime(DateTime.Parse("2016-08-31T10:00:00", CultureInfo.InvariantCulture), _tzid);
-        Assert.That(occurrences[2].StartTime.Equals(secondExpectedRDate), Is.True);
+        var secondExpectedRDate = new CalDateTime(DateTime.Parse("2016-08-31T10:00:00", CultureInfo.InvariantCulture), _tzid).ToZonedDateTime();
+        Assert.That(occurrences[2].Start.Equals(secondExpectedRDate), Is.True);
     }
 
     [Test]
@@ -3260,20 +2925,21 @@ public void OccurrenceMustBeCompletelyContainedWithinSearchRange()
         var startSearch = new CalDateTime(DateTime.Parse("2016-07-01T00:00:00", CultureInfo.InvariantCulture), "UTC");
         var endSearch = new CalDateTime(DateTime.Parse("2016-08-31T07:00:00", CultureInfo.InvariantCulture), "UTC");
 
-        var lastExpected = new CalDateTime(DateTime.Parse("2016-08-31T07:00:00", CultureInfo.InvariantCulture), "UTC");
-        var occurrences = firstEvent.GetOccurrences(startSearch).TakeWhileBefore(endSearch)
+        var lastExpected = new CalDateTime(DateTime.Parse("2016-08-31T07:00:00", CultureInfo.InvariantCulture), "UTC").ToZonedDateTime();
+        var occurrences = firstEvent.GetOccurrences(startSearch.ToZonedDateTime())
+            .TakeWhileBefore(endSearch.ToZonedDateTime().ToInstant())
             .Select(o => o.Period)
             .ToList();
 
-        Assert.That(occurrences.Last().StartTime.Equals(lastExpected), Is.False);
+        Assert.That(occurrences.Last().Start.Equals(lastExpected), Is.False);
 
         //Create 1 second of overlap
         endSearch = new CalDateTime(endSearch.Value.AddSeconds(1), "UTC");
-        occurrences = firstEvent.GetOccurrences(startSearch).TakeWhileBefore(endSearch)
+        occurrences = firstEvent.GetOccurrences(startSearch.ToZonedDateTime()).TakeWhileBefore(endSearch.ToZonedDateTime().ToInstant())
             .Select(o => o.Period)
             .ToList();
 
-        Assert.That(occurrences.Last().StartTime.Equals(lastExpected), Is.True);
+        Assert.That(occurrences.Last().Start.Equals(lastExpected), Is.True);
     }
 
     [Test, Category("RECURRENCE-ID")]
@@ -3338,30 +3004,24 @@ public void EventWithZonedRecurrenceId_Should_ReplaceOriginalEvent_Occurrence()
 
         var calendar = Calendar.Load(ical)!;
 
-        var orderedOccurrences = calendar.GetOccurrences()
+        var orderedOccurrences = calendar.GetOccurrences(DateUtil.GetZone("Europe/Bucharest"))
             .Take(10)
             .ToList();
 
-        // This occurrence was modified using RECURRENCE-ID
-        var expectedSept1Start = new CalDateTime(DateTime.Parse("2016-09-01T16:30:00", CultureInfo.InvariantCulture),
-            "Europe/Bucharest");
-        var expectedSept1End = new CalDateTime(DateTime.Parse("2016-09-01T22:00:00", CultureInfo.InvariantCulture),
-            "Europe/Bucharest");
+        var expectedSept1Start = new CalDateTime(DateTime.Parse("2016-09-01T16:30:00", CultureInfo.InvariantCulture), "Europe/Bucharest").ToZonedDateTime();
+        var expectedSept1End = new CalDateTime(DateTime.Parse("2016-09-01T22:00:00", CultureInfo.InvariantCulture), "Europe/Bucharest").ToZonedDateTime();
         Assert.Multiple(() =>
         {
-            Assert.That(orderedOccurrences[3].Period.StartTime, Is.EqualTo(expectedSept1Start));
-            Assert.That(orderedOccurrences[3].Period.EffectiveEndTime, Is.EqualTo(expectedSept1End));
+            Assert.That(orderedOccurrences[3].Start, Is.EqualTo(expectedSept1Start));
+            Assert.That(orderedOccurrences[3].End, Is.EqualTo(expectedSept1End));
         });
 
-        // This occurrence was modified using RECURRENCE-ID
-        var expectedSept3Start = new CalDateTime(DateTime.Parse("2016-09-03T07:00:00", CultureInfo.InvariantCulture),
-            "Europe/Bucharest");
-        var expectedSept3End = new CalDateTime(DateTime.Parse("2016-09-03T12:30:00", CultureInfo.InvariantCulture),
-            "Europe/Bucharest");
+        var expectedSept3Start = new CalDateTime(DateTime.Parse("2016-09-03T07:00:00", CultureInfo.InvariantCulture), "Europe/Bucharest").ToZonedDateTime();
+        var expectedSept3End = new CalDateTime(DateTime.Parse("2016-09-03T12:30:00", CultureInfo.InvariantCulture), "Europe/Bucharest").ToZonedDateTime();
         Assert.Multiple(() =>
         {
-            Assert.That(orderedOccurrences[5].Period.StartTime, Is.EqualTo(expectedSept3Start));
-            Assert.That(orderedOccurrences[5].Period.EffectiveEndTime, Is.EqualTo(expectedSept3End));
+            Assert.That(orderedOccurrences[5].Start, Is.EqualTo(expectedSept3Start));
+            Assert.That(orderedOccurrences[5].End, Is.EqualTo(expectedSept3End));
         });
     }
 
@@ -3398,8 +3058,8 @@ private static CalendarEvent GetEventWithRecurrenceRules()
 
         var calendarEvent = new CalendarEvent
         {
-            Start = new CalDateTime(_now),
-            End = new CalDateTime(_later),
+            Start = _now,
+            End = _later,
             RecurrenceRules = new List<RecurrencePattern> { dailyForFiveDays },
             Resources = new List<string>(new[] { "Foo", "Bar", "Baz" }),
         };
@@ -3411,20 +3071,20 @@ public void ExDatesShouldGetMergedInOutput()
     {
         var start = _now.AddYears(-1);
         var end = start.AddHours(1);
-        var rrule = new RecurrencePattern(FrequencyType.Daily) { Until = new CalDateTime(start.AddYears(2)) };
+        var rrule = new RecurrencePattern(FrequencyType.Daily) { Until = start.AddYears(2) };
         var e = new CalendarEvent
         {
-            DtStart = new CalDateTime(start),
-            DtEnd = new CalDateTime(end),
+            DtStart = start,
+            DtEnd = end,
             RecurrenceRules = new List<RecurrencePattern> { rrule }
         };
 
-        var firstExclusion = new CalDateTime(start.AddDays(4));
+        var firstExclusion = start.AddDays(4);
         e.ExceptionDates.Add(firstExclusion);
         var serialized = SerializationHelpers.SerializeToString(e);
         Assert.That(Regex.Matches(serialized, "EXDATE:"), Has.Count.EqualTo(1));
 
-        var secondExclusion = new CalDateTime(start.AddDays(5));
+        var secondExclusion = start.AddDays(5);
         e.ExceptionDates.Add(secondExclusion);
         serialized = SerializationHelpers.SerializeToString(e);
         Assert.That(Regex.Matches(serialized, "EXDATE:"), Has.Count.EqualTo(1));
@@ -3493,21 +3153,21 @@ public void SpecificMinute()
         vEvent.RecurrenceRules.Add(rrule);
 
         // Exactly on start time
-        var testingTime = new CalDateTime(2019, 6, 7, 9, 0, 0);
+        var testingTime = new CalDateTime(2019, 6, 7, 9, 0, 0).ToZonedDateTime(_tzid);
 
-        var occurrences = vEvent.GetOccurrences(testingTime).TakeWhile(p => p.Period.StartTime == testingTime).ToList();
+        var occurrences = vEvent.GetOccurrences(testingTime).TakeWhile(p => p.Start == testingTime).ToList();
         Assert.That(occurrences, Has.Count.EqualTo(1));
 
         // One second before end time
-        testingTime = new CalDateTime(2019, 6, 7, 16, 59, 59);
+        testingTime = new CalDateTime(2019, 6, 7, 16, 59, 59).ToZonedDateTime(_tzid);
 
-        occurrences = vEvent.GetOccurrences(testingTime).TakeWhileBefore(testingTime).ToList();
+        occurrences = vEvent.GetOccurrences(testingTime).TakeWhileBefore(testingTime.ToInstant()).ToList();
         Assert.That(occurrences, Has.Count.EqualTo(1));
 
         // Exactly on end time
-        testingTime = new CalDateTime(2019, 6, 7, 17, 0, 0);
+        testingTime = new CalDateTime(2019, 6, 7, 17, 0, 0).ToZonedDateTime(_tzid);
 
-        occurrences = vEvent.GetOccurrences(testingTime).TakeWhileBefore(testingTime).ToList();
+        occurrences = vEvent.GetOccurrences(testingTime).TakeWhileBefore(testingTime.ToInstant()).ToList();
         Assert.That(occurrences.Count, Is.EqualTo(0));
     }
 
@@ -3810,7 +3470,9 @@ Type LoadType(string name) =>
 
         evt.RecurrenceRules.Add(GetPattern());
 
-        IEnumerable<Occurrence> GetOccurrences() => evt.GetOccurrences(testCase.StartAt ?? null);
+        var startAt = testCase.StartAt?.ToZonedDateTime(_tzid).ToInstant();
+
+        IEnumerable<Occurrence> GetOccurrences() => evt.GetOccurrences(DateUtil.GetZone(_tzid), startAt);
 
         if (testCase.ExceptionStep == RecurrenceTestExceptionStep.GetOccurrenceInvocation)
         {
@@ -3824,14 +3486,14 @@ Type LoadType(string name) =>
 
         if (testCase.ExceptionStep == RecurrenceTestExceptionStep.Enumeration)
         {
-            Assert.That(() => EnumerateOccurrences().Last().Period.EffectiveEndTime, throwsConstraint);
+            Assert.That(() => EnumerateOccurrences().Last().End, throwsConstraint);
             return;
         }
 
         var occurrences = EnumerateOccurrences();
 
-        var startDates = occurrences.Select(x => x.Period.StartTime).ToList();
-        Assert.That(startDates, Is.EqualTo(testCase.Instances));
+        var startDates = occurrences.Select(x => x.Start).ToList();
+        Assert.That(startDates, Is.EqualTo(testCase.Instances?.Select(x => x.ToZonedDateTime(_tzid)).ToList()));
     }
 
     [Test]
@@ -3852,7 +3514,7 @@ public void ShouldCreateARecurringYearlyEvent()
         calendar.Events.Add(springAdminEvent);
         var searchStart = new CalDateTime(2024, 04, 15);
         var searchEnd = new CalDateTime(2050, 05, 31);
-        var occurrences = calendar.GetOccurrences(searchStart).TakeWhileBefore(searchEnd);
+        var occurrences = calendar.GetOccurrences(searchStart.ToZonedDateTime("US/Eastern")).TakeWhileBefore(searchEnd);
         Assert.That(occurrences.Count, Is.EqualTo(27));
 
         springAdminEvent.Start = new CalDateTime(2024, 04, 16);
@@ -3862,7 +3524,7 @@ public void ShouldCreateARecurringYearlyEvent()
 
         searchStart = new CalDateTime(2024, 04, 16);
         searchEnd = new CalDateTime(2050, 05, 31);
-        occurrences = calendar.GetOccurrences(searchStart).TakeWhileBefore(searchEnd);
+        occurrences = calendar.GetOccurrences(searchStart.ToZonedDateTime("US/Eastern")).TakeWhileBefore(searchEnd);
 
         // occurrences are 26 here, omitting 4/16/2024
         Assert.That(occurrences.Count, Is.EqualTo(27));
@@ -3887,7 +3549,7 @@ public void GetOccurrenceShouldExcludeDtEndFloating()
 
         var calendar = Calendar.Load(ical)!;
         // Set start date for occurrences to search to the end date of the event
-        var occurrences = calendar.GetOccurrences(new CalDateTime(2024, 12, 2))
+        var occurrences = calendar.GetOccurrences(new CalDateTime(2024, 12, 2).ToZonedDateTime("US/Eastern"))
             .TakeWhileBefore(new CalDateTime(2024, 12, 3));
 
         Assert.That(occurrences, Is.Empty);
@@ -3913,7 +3575,7 @@ public void TestGetOccurrenceIndefinite()
 
         // Although the occurrences are unbounded, we can still call GetOccurrences without
         // specifying bounds, because the instances are only generated on enumeration.
-        var occurrences = calendar.GetOccurrences();
+        var occurrences = calendar.GetOccurrences(DateUtil.GetZone(_tzid));
 
         var instances = occurrences.Take(100).ToList();
 
@@ -3921,11 +3583,10 @@ public void TestGetOccurrenceIndefinite()
     }
 
     [Test, Category("Recurrence")]
-    [TestCase(null)]
     [TestCase("UTC")]
     [TestCase("Europe/Vienna")]
     [TestCase("America/New_York")]
-    public void TestDtStartTimezone(string? tzId)
+    public void TestDtStartTimezone(string tzId)
     {
         var icalText = """
                        BEGIN:VCALENDAR
@@ -3942,14 +3603,16 @@ public void TestDtStartTimezone(string? tzId)
         var cal = Calendar.Load(icalText)!;
         var evt = cal.Events.First();
         var ev = new EventEvaluator(evt);
-        var occurrences = ev.Evaluate(evt.DtStart!, evt.DtStart!.ToTimeZone(tzId), null)
-            .TakeWhileBefore(evt.DtStart.AddMinutes(61).ToTimeZone(tzId));
-        var occurrencesStartTimes = occurrences.Select(x => x.StartTime).Take(2).ToList();
+
+        var occurrences = ev.Evaluate(evt.DtStart!, evt.DtStart!.ToZonedDateTime(tzId), null)
+            .TakeWhileBefore(evt.DtStart.AddMinutes(61).ToZonedDateTime(tzId).ToInstant());
+
+        var occurrencesStartTimes = occurrences.Select(x => x.Start).Take(2).ToList();
 
         var expectedStartTimes = new[]
         {
-            new CalDateTime(2018, 06, 12, 18, 0, 0, "Europe/Vienna"),
-            new CalDateTime(2018, 06, 12, 19, 0, 0, "Europe/Vienna"),
+            new CalDateTime(2018, 06, 12, 18, 0, 0, "Europe/Vienna").ToZonedDateTime(tzId),
+            new CalDateTime(2018, 06, 12, 19, 0, 0, "Europe/Vienna").ToZonedDateTime(tzId),
         };
 
         Assert.That(expectedStartTimes.SequenceEqual(occurrencesStartTimes), Is.True);
@@ -3996,7 +3659,7 @@ public void TestMaxIncrementCount(int? limit, string ical, bool expectException)
                 ? Throws.Exception.TypeOf<EvaluationLimitExceededException>()
                 : Throws.Nothing;
 
-        Assert.That(() => cal.GetOccurrences(options: options).ToList(), constraint);
+        Assert.That(() => cal.GetOccurrences(DateUtil.GetZone(_tzid), options: options).ToList(), constraint);
     }
 
     [TestCase("FREQ=DAILY;INTERVAL=2;UNTIL=20250430T000000Z")]
@@ -4095,21 +3758,22 @@ public void AmbiguousLocalTime_WithShortDurationOfRecurrence()
                   END:VCALENDAR
                   """;
         var cal = Calendar.Load(ics)!;
-        var occ = cal.GetOccurrences().ToList();
+
+        var tz = DateUtil.GetZone("Europe/Vienna");
+
+        var occ = cal.GetOccurrences(tz).ToList();
 
         Assert.Multiple(() =>
         {
             Assert.That(occ.Count, Is.EqualTo(2));
 
-            Assert.That(occ[0].Period.StartTime, Is.EqualTo(new CalDateTime(2020, 10, 24, 2, 30, 0, "Europe/Vienna")));
-            Assert.That(occ[0].Period.EffectiveEndTime,
-                Is.EqualTo(new CalDateTime(2020, 10, 24, 3, 15, 0, "Europe/Vienna")));
-            Assert.That(occ[0].Period.EffectiveDuration, Is.EqualTo(new Duration(0, 0, 0, 45, 0)));
+            Assert.That(occ[0].Start, Is.EqualTo(tz.MapLocal(new(2020, 10, 24, 2, 30)).First()));
+            Assert.That(occ[0].End, Is.EqualTo(tz.MapLocal(new(2020, 10, 24, 3, 15, 0)).First()));
+            Assert.That(occ[0].End - occ[0].Start, Is.EqualTo(NodaTime.Duration.FromMinutes(45)));
 
-            Assert.That(occ[1].Period.StartTime, Is.EqualTo(new CalDateTime(2020, 10, 25, 2, 30, 0, "Europe/Vienna")));
-            Assert.That(occ[1].Period.EffectiveEndTime,
-                Is.EqualTo(new CalDateTime(2020, 10, 25, 2, 15, 0, "Europe/Vienna")));
-            Assert.That(occ[1].Period.EffectiveDuration, Is.EqualTo(new Duration(0, 0, 0, 45, 0)));
+            Assert.That(occ[1].Start, Is.EqualTo(tz.MapLocal(new(2020, 10, 25, 2, 30, 0)).First()));
+            Assert.That(occ[1].End, Is.EqualTo(tz.MapLocal(new(2020, 10, 25, 2, 15, 0)).Last()));
+            Assert.That(occ[1].End - occ[1].Start, Is.EqualTo(NodaTime.Duration.FromMinutes(45)));
         });
     }
 
@@ -4128,16 +3792,16 @@ public void GetOccurrences_ShouldNotIgnoreExDatesForToday(string periodStart, st
 
         cal.ExceptionDates.Add(new CalDateTime("20250102"));
 
-        var occurrences = cal.GetOccurrences(new CalDateTime(periodStart))
+        var occurrences = cal.GetOccurrences(new CalDateTime(periodStart).ToZonedDateTime(_tzid))
             .Take(2)
-            .Select(o => o.Period.StartTime)
+            .Select(o => o.Start)
             .ToList();
 
         var expectedDates = new[]
         {
             new CalDateTime(expected1),
             new CalDateTime(expected2)
-        };
+        }.Select(x => x.ToZonedDateTime(_tzid)).ToList();
 
         Assert.That(occurrences, Is.EqualTo(expectedDates));
     }
@@ -4162,16 +3826,16 @@ public void GetOccurrences_WithMixedKindExDates_ShouldProperlyConsiderAll()
         // Should be considered only at the exact time
         cal.ExceptionDates.Add(new CalDateTime("20250703T150000"));
 
-        var occurrences = cal.GetOccurrences()
+        var occurrences = cal.GetOccurrences(DateUtil.GetZone(_tzid))
             .Take(2)
-            .Select(o => o.Period.StartTime)
+            .Select(o => o.Start)
             .ToList();
 
         var expectedDates = new[]
         {
             new CalDateTime("20250702T100000"),
             new CalDateTime("20250704T100000")
-        };
+        }.Select(x => x.ToZonedDateTime(_tzid)).ToList();
 
         Assert.That(occurrences, Is.EqualTo(expectedDates));
     }
@@ -4192,10 +3856,8 @@ public void GetOccurrences_WithMixedKindExDatesAndTz_ShouldProperlyConsiderAll()
                                 END:VCALENDAR
                                 """)!;
 
-        var evt = cal.Events.Single();
-
-        var occurrences = cal.GetOccurrences()
-            .Select(o => o.Period.StartTime)
+        var occurrences = cal.GetOccurrences(DateUtil.GetZone(_tzid))
+            .Select(o => o.Start)
             .ToList();
 
         var expectedDates = new[]
@@ -4214,7 +3876,7 @@ public void GetOccurrences_WithMixedKindExDatesAndTz_ShouldProperlyConsiderAll()
             // same as above. All-day EXDATEs are matched against the date in the RDATE's time zone,
             // so 20250702 isn't excluded even though on Jul 3 in DTSTART's TZ.
             new CalDateTime("20250702T234500", "Etc/GMT+12"),
-        };
+        }.Select(x => x.ToZonedDateTime(_tzid)).ToList();
 
         Assert.That(occurrences, Is.EqualTo(expectedDates));
     }
@@ -4234,25 +3896,26 @@ public void GetOccurrences_WithPeriodStart_ShouldConsiderDurationCorrectly()
                                 END:VCALENDAR
                                 """)!;
 
-        var occurrences = cal.GetOccurrences(new CalDateTime("20250710T120000"))
-            .Select(o => o.Period.StartTime)
+        var occurrences = cal.GetOccurrences(new CalDateTime("20250710T120000").ToZonedDateTime(_tzid))
+            .Select(o => o.Start)
             .Take(5)
             .ToList();
 
         var expectedDates = new string[]
-            {
-                // RDATE
-                "20250707T000000",
-                // RRULE
-                "20250708T000000",
-                // RDATE
-                "20250710T000000",
-                // RRULE
-                "20250715T000000",
-                // RRULE
-                "20250722T000000",
-            }.Select(x => new CalDateTime(x))
-            .ToList();
+        {
+            // RDATE
+            "20250707T000000",
+            // RRULE
+            "20250708T000000",
+            // RDATE
+            "20250710T000000",
+            // RRULE
+            "20250715T000000",
+            // RRULE
+            "20250722T000000",
+        }.Select(x => new CalDateTime(x))
+        .Select(x => x.ToZonedDateTime(_tzid))
+        .ToList();
 
         Assert.That(occurrences, Is.EqualTo(expectedDates));
     }
@@ -4261,7 +3924,7 @@ public void GetOccurrences_WithPeriodStart_ShouldConsiderDurationCorrectly()
     [TestCase("20250715T120000", "UTC", "20260715T120000", "UTC")]
     [TestCase("20250715T120000", "UTC", "20260715T140000", "Etc/GMT-2")]
     [TestCase("20250715T120000", "UTC", "20260715T100000", "Etc/GMT+2")]
-    [TestCase("20250715T120000", "UTC", "20260715T120000", null)]
+    [TestCase("20250715T120000", "UTC", "20260715T080000", null)]
     [TestCase("20250715T120000", null, "20260715T120000", "Etc/GMT-2")]
     [TestCase("20250715T120000", null, "20260715T120000", "Etc/GMT+2")]
     [TestCase("20250715T120000", null, "20260715T120000", "UTC")]
@@ -4288,12 +3951,15 @@ public void GetOccurrences_WithPeriodStart_ShouldConsiderTzCorrectly(string dtSt
         var cal = new Calendar();
         cal.Events.Add(evt);
 
-        var firstFewOccurrences = cal.GetOccurrences().Take(3).ToList();
+        var tz = DateUtil.GetZone(periodStartTzId ?? _tzid);
+
+        var firstFewOccurrences = cal.GetOccurrences(tz).Take(3).ToList();
 
         var periodStart = new CalDateTime(periodStartStr, periodStartTzId);
-        Assert.That(cal.GetOccurrences(periodStart).First(), Is.EqualTo(firstFewOccurrences[1]));
+        var zonedStart = periodStart.ToZonedDateTime(tz);
+        Assert.That(cal.GetOccurrences(zonedStart).First(), Is.EqualTo(firstFewOccurrences[1]));
 
-        var nextPeriodStart = periodStart.HasTime ? periodStart.AddSeconds(1) : periodStart.AddDays(1);
+        var nextPeriodStart = periodStart.HasTime ? zonedStart.PlusSeconds(1) : zonedStart.PlusHours(24);
         Assert.That(cal.GetOccurrences(nextPeriodStart).First(), Is.EqualTo(firstFewOccurrences[2]));
     }
 
@@ -4327,8 +3993,10 @@ public void EventWithRecurrenceId_Should_ReplaceOriginalEvent_Occurrence(string
                                  END:VCALENDAR
                                  """)!;
 
+        var tz = DateUtil.GetZone(_tzid);
+
         var occurrences = cal
-            .GetOccurrences<CalendarEvent>().ToList();
+            .GetOccurrences<CalendarEvent>(tz).ToList();
 
         var overrideOcc = occurrences.FirstOrDefault(o => o.Source.RecurrenceId == new CalDateTime(2025, 11, 3));
 
@@ -4336,10 +4004,10 @@ public void EventWithRecurrenceId_Should_ReplaceOriginalEvent_Occurrence(string
         {
             Assert.That(occurrences, Has.Count.EqualTo(4));
             Assert.That(overrideOcc, Is.Not.Null);
-            Assert.That(overrideOcc!.Period.StartTime,
-                Is.EqualTo(new CalDateTime(dtStart.Year, dtStart.Month, dtStart.Day)));
+            Assert.That(overrideOcc!.Start,
+                Is.EqualTo(new CalDateTime(dtStart.Year, dtStart.Month, dtStart.Day).ToZonedDateTime(tz)));
             Assert.That(((CalendarEvent) overrideOcc.Source).Summary, Is.EqualTo("Override Event"));
-            if (overrideOcc.Period.StartTime.Year == 2028) Assert.That(occurrences.IndexOf(overrideOcc), Is.EqualTo(2));
+            if (overrideOcc.Start.Year == 2028) Assert.That(occurrences.IndexOf(overrideOcc), Is.EqualTo(2));
         }
     }
 
@@ -4377,8 +4045,10 @@ public void EventWithRecurrenceId_LatestInOrderOverride_ShouldBeTaken()
                                 END:VCALENDAR
                                 """)!;
 
+        var tz = DateUtil.GetZone(_tzid);
+
         var occurrences = cal
-            .GetOccurrences<CalendarEvent>().ToList();
+            .GetOccurrences<CalendarEvent>(tz).ToList();
 
         var overrideOcc = occurrences.FirstOrDefault(o => o.Source.RecurrenceId == new CalDateTime(2025, 11, 3));
 
@@ -4386,8 +4056,8 @@ public void EventWithRecurrenceId_LatestInOrderOverride_ShouldBeTaken()
         {
             Assert.That(occurrences, Has.Count.EqualTo(4));
             Assert.That(overrideOcc, Is.Not.Null);
-            Assert.That(overrideOcc!.Period.StartTime,
-                Is.EqualTo(new CalDateTime(2025, 11, 5)));
+            Assert.That(overrideOcc!.Start,
+                Is.EqualTo(new CalDateTime(2025, 11, 5).ToZonedDateTime(tz)));
             // The last override in the calendar is taken
             Assert.That(((CalendarEvent) overrideOcc.Source).Summary, Is.EqualTo("Override Event 2"));
         }
@@ -4429,8 +4099,10 @@ public void EventWithRecurrenceId_LatestSequence_ShouldBeTaken()
                                 END:VCALENDAR
                                 """)!;
 
+        var tz = DateUtil.GetZone(_tzid);
+
         var occurrences = cal
-            .GetOccurrences<CalendarEvent>().ToList();
+            .GetOccurrences<CalendarEvent>(tz).ToList();
 
         var overrideOcc = occurrences.FirstOrDefault(o => o.Source.RecurrenceId == new CalDateTime(2025, 11, 3));
 
@@ -4438,8 +4110,8 @@ public void EventWithRecurrenceId_LatestSequence_ShouldBeTaken()
         {
             Assert.That(occurrences, Has.Count.EqualTo(4));
             Assert.That(overrideOcc, Is.Not.Null);
-            Assert.That(overrideOcc!.Period.StartTime,
-                Is.EqualTo(new CalDateTime(2025, 11, 4)));
+            Assert.That(overrideOcc!.Start,
+                Is.EqualTo(new CalDateTime(2025, 11, 4).ToZonedDateTime(tz)));
             // The override with the highest SEQUENCE is taken, even if it comes earlier in the calendar
             Assert.That(((CalendarEvent) overrideOcc.Source).Summary, Is.EqualTo("Override Event 2"));
         }
@@ -4466,20 +4138,25 @@ public void SkippedOccurrenceOnWeeklyPattern() // Test moved from former GetOccu
         var calendar = new Calendar();
         calendar.Events.Add(vEvent);
 
-        var intervalStart = eventStart;
-        var intervalEnd = intervalStart.AddDays(7 * evaluationsCount);
+        var tz = DateUtil.GetZone("UTC");
+
+        var intervalStart = eventStart.ToZonedDateTime(tz);
+        var intervalEnd = intervalStart.LocalDateTime
+            .PlusDays(7 * evaluationsCount)
+            .InZoneLeniently(tz)
+            .ToInstant();
 
         var occurrences = RecurrenceUtil.GetOccurrences(
                 recurrable: vEvent,
                 periodStart: intervalStart)
             .TakeWhileBefore(intervalEnd);
-        var occurrenceSet = new HashSet<CalDateTime>(occurrences.Select(o => o.Period.StartTime));
+        var occurrenceSet = occurrences.Select(o => o.Start).ToHashSet();
 
         Assert.That(occurrenceSet, Has.Count.EqualTo(evaluationsCount));
 
         for (var currentOccurrence = intervalStart;
-             currentOccurrence.CompareTo(intervalEnd) < 0;
-             currentOccurrence = (CalDateTime) currentOccurrence.AddDays(7))
+             currentOccurrence.ToInstant() < intervalEnd;
+             currentOccurrence = currentOccurrence.LocalDateTime.PlusDays(7).InZoneLeniently(tz))
         {
             var contains = occurrenceSet.Contains(currentOccurrence);
             Assert.That(contains, Is.True,
@@ -4502,26 +4179,28 @@ public void GetOccurrences_ShouldReturnCorrectStartAndEndTimes()
         calendar.Events.Add(vEvent);
         calendar.Events.Add(vEvent2);
 
-        var searchStart = new CalDateTime(2015, 12, 29);
-        var searchEnd = new CalDateTime(2017, 02, 10);
+        var tz = DateUtil.GetZone(_tzid);
+
+        var searchStart = new CalDateTime(2015, 12, 29).ToZonedDateTime(tz);
+        var searchEnd = new CalDateTime(2017, 02, 10).ToZonedDateTime(tz).ToInstant();
         var occurrences = calendar.GetOccurrences(searchStart).TakeWhileBefore(searchEnd).ToList();
 
         var firstOccurrence = occurrences.First();
-        var firstStartCopy = firstStart.Copy();
-        var firstEndCopy = firstEnd.Copy();
+        var firstStartCopy = firstStart.ToZonedDateTime(tz);
+        var firstEndCopy = firstEnd.ToZonedDateTime(tz);
         Assert.Multiple(() =>
         {
-            Assert.That(firstOccurrence.Period.StartTime, Is.EqualTo(firstStartCopy));
-            Assert.That(firstOccurrence.Period.EffectiveEndTime, Is.EqualTo(firstEndCopy));
+            Assert.That(firstOccurrence.Start, Is.EqualTo(firstStartCopy));
+            Assert.That(firstOccurrence.End, Is.EqualTo(firstEndCopy));
         });
 
         var secondOccurrence = occurrences.Last();
-        var secondStartCopy = secondStart.Copy();
-        var secondEndCopy = secondEnd.Copy();
+        var secondStartCopy = secondStart.ToZonedDateTime(tz);
+        var secondEndCopy = secondEnd.ToZonedDateTime(tz);
         Assert.Multiple(() =>
         {
-            Assert.That(secondOccurrence.Period.StartTime, Is.EqualTo(secondStartCopy));
-            Assert.That(secondOccurrence.Period.EffectiveEndTime, Is.EqualTo(secondEndCopy));
+            Assert.That(secondOccurrence.Start, Is.EqualTo(secondStartCopy));
+            Assert.That(secondOccurrence.End, Is.EqualTo(secondEndCopy));
         });
     }
 
@@ -4581,36 +4260,38 @@ public void GetOccurrencesWithRecurrenceIdShouldEnumerate()
                             END:VCALENDAR
                             """;
 
+        var tz = DateUtil.GetZone("W. Europe Standard Time");
+
         var collection = Calendar.Load(ical)!;
-        var startCheck = new CalDateTime(2016, 11, 11);
+        var startCheck = new CalDateTime(2016, 11, 11).ToZonedDateTime(tz);
         var occurrences = collection.GetOccurrences<CalendarEvent>(startCheck)
-            .TakeWhileBefore(startCheck.AddMonths(1)).ToList();
-
-        CalDateTime[] expectedStartDates =
-        [
-            new CalDateTime("20161114T000100", "W. Europe Standard Time"),
-            new CalDateTime("20161114T120100", "W. Europe Standard Time"),
-            new CalDateTime("20161121T000100", "W. Europe Standard Time"),
-            new CalDateTime("20161121T120100", "W. Europe Standard Time"),
-            new CalDateTime("20161128T043000", "W. Europe Standard Time"), // The replaced entry
-            new CalDateTime("20161128T120100", "W. Europe Standard Time"),
-            new CalDateTime("20161205T000100", "W. Europe Standard Time"),
-            new CalDateTime("20161205T120100", "W. Europe Standard Time")
-        ];
+            .TakeWhileBefore(startCheck.LocalDateTime.PlusMonths(1).InZoneLeniently(tz).ToInstant()).ToList();
+
+        var expectedStartDates = new List<CalDateTime>
+        {
+            new("20161114T000100", "W. Europe Standard Time"),
+            new("20161114T120100", "W. Europe Standard Time"),
+            new("20161121T000100", "W. Europe Standard Time"),
+            new("20161121T120100", "W. Europe Standard Time"),
+            new("20161128T043000", "W. Europe Standard Time"), // The replaced entry
+            new("20161128T120100", "W. Europe Standard Time"),
+            new("20161205T000100", "W. Europe Standard Time"),
+            new("20161205T120100", "W. Europe Standard Time")
+        }.Select(x => x.ToZonedDateTime()).ToList();
 
         // Specify end time that is between the original occurrence at 20161128T0001 and the overridden one at 20161128T0030.
         // The overridden one shouldn't be returned, because it was replaced and the other one is in the future.
-        var occurrences2 = collection.GetOccurrences<CalendarEvent>(new CalDateTime(startCheck))
-            .TakeWhileBefore(new CalDateTime("20161128T002000", "W. Europe Standard Time"))
+        var occurrences2 = collection.GetOccurrences<CalendarEvent>(startCheck)
+            .TakeWhileBefore(new CalDateTime("20161128T002000", "W. Europe Standard Time").ToInstant())
             .ToList();
 
         Assert.Multiple(() =>
         {
             // endTime = 20161211T000000
-            Assert.That(occurrences.Select(x => x.Period.StartTime), Is.EqualTo(expectedStartDates));
+            Assert.That(occurrences.Select(x => x.Start), Is.EqualTo(expectedStartDates));
 
             // endTime = 20161128T002000
-            Assert.That(occurrences2.Select(x => x.Period.StartTime), Is.EqualTo(expectedStartDates.Take(4)));
+            Assert.That(occurrences2.Select(x => x.Start), Is.EqualTo(expectedStartDates.Take(4)));
         });
     }
 
@@ -4638,36 +4319,39 @@ public void GetOccurrencesWithRecurrenceId_DateOnly_ShouldEnumerate()
                             END:VCALENDAR
                             """;
 
+        var tz = DateUtil.GetZone(_tzid);
+
         var collection = Calendar.Load(ical)!;
-        var startCheck = new CalDateTime(2023, 10, 1);
+        var startCheck = new CalDateTime(2023, 10, 1).ToZonedDateTime(tz);
         var occurrences = collection.GetOccurrences<CalendarEvent>(startCheck)
-            .TakeWhileBefore(startCheck.AddMonths(1))
+            .TakeWhileBefore(startCheck.LocalDateTime.PlusMonths(1).InZoneLeniently(tz).ToInstant())
             .ToList();
 
-        var occurrences2 = collection.GetOccurrences<CalendarEvent>(new CalDateTime(startCheck))
-            .TakeWhileBefore(new CalDateTime(2023, 12, 31))
+        var occurrences2 = collection.GetOccurrences<CalendarEvent>(startCheck)
+            .TakeWhileBefore(new CalDateTime(2023, 12, 31).ToZonedDateTime(tz).ToInstant())
             .ToList();
 
-        CalDateTime[] expectedStartDates =
-        [
+        var expectedStartDates = new List<CalDateTime>
+        {
             new(2023, 10, 1),
             new(2023, 11, 15), // the replaced occurrence
             new(2023, 12, 1)
-        ];
+        }.Select(x => x.ToZonedDateTime(tz)).ToList();
 
         Assert.Multiple(() =>
         {
             // For endTime=20231002
-            Assert.That(occurrences.Select(x => x.Period.StartTime), Is.EqualTo(expectedStartDates.Take(1)));
+            Assert.That(occurrences.Select(x => x.Start), Is.EqualTo(expectedStartDates.Take(1)));
 
             // For endTime=20231231
-            Assert.That(occurrences2.Select(x => x.Period.StartTime), Is.EqualTo(expectedStartDates.Take(3)));
+            Assert.That(occurrences2.Select(x => x.Start), Is.EqualTo(expectedStartDates.Take(3)));
         });
     }
 
     [Test]
     public void CalendarCollection_GetOccurrences_ShouldEnumerateAndMerge()
     {
+        var tz = DateUtil.GetZone(_tzid);
         var cal1 = new Calendar();
         cal1.Events.Add(
             new CalendarEvent { DtStart = new CalDateTime(2025, 1, 1), DtEnd = new CalDateTime(2025, 1, 2) });
@@ -4679,11 +4363,11 @@ public void CalendarCollection_GetOccurrences_ShouldEnumerateAndMerge()
         var collection = new CalendarCollection { cal1, cal2 };
 
         // Runs OrderedMergeMany
-        var occurrences = collection.GetOccurrences().ToList();
+        var occurrences = collection.GetOccurrences(tz).ToList();
         Assert.That(occurrences.Count, Is.EqualTo(2));
 
         // Generic overload
-        var occurrencesTyped = collection.GetOccurrences<CalendarEvent>().ToList();
+        var occurrencesTyped = collection.GetOccurrences<CalendarEvent>(tz).ToList();
         Assert.That(occurrencesTyped.Count, Is.EqualTo(2));
     }
 
@@ -4712,8 +4396,8 @@ public void GetOccurrences_ShouldPreserveDuplicatesAcrossComponents()
                    """;
 
         var cal = Calendar.Load(ical)!;
-        var from = new CalDateTime(2025, 01, 01, 0, 0, 0, CalDateTime.UtcTzId);
-        var to = new CalDateTime(2025, 01, 04, 0, 0, 0, CalDateTime.UtcTzId);
+        var from = new CalDateTime(2025, 01, 01, 0, 0, 0, CalDateTime.UtcTzId).ToZonedDateTime();
+        var to = new CalDateTime(2025, 01, 04, 0, 0, 0, CalDateTime.UtcTzId).ToZonedDateTime().ToInstant();
 
         var occurrences = cal.GetOccurrences(from).TakeWhileBefore(to).ToList();
 
@@ -4726,9 +4410,9 @@ public void GetOccurrences_ShouldPreserveDuplicatesAcrossComponents()
             new CalDateTime(2025, 01, 02, 10, 0, 0, CalDateTime.UtcTzId),
             new CalDateTime(2025, 01, 03, 10, 0, 0, CalDateTime.UtcTzId),
             new CalDateTime(2025, 01, 03, 10, 0, 0, CalDateTime.UtcTzId),
-        };
+        }.Select(x => x.ToZonedDateTime()).ToList();
 
-        Assert.That(occurrences.Select(o => o.Period.StartTime).ToArray(), Is.EqualTo(expected));
+        Assert.That(occurrences.Select(o => o.Start).ToArray(), Is.EqualTo(expected));
     }
 
     [Test, Category("RECURRENCE-ID")]
@@ -4762,8 +4446,8 @@ public void GetOccurrences_WithMultipleOverridesForSameRecurrenceId_ShouldUseLat
                    """;
 
         var cal = Calendar.Load(ical)!;
-        var from = new CalDateTime(2025, 01, 01, 0, 0, 0, CalDateTime.UtcTzId);
-        var to = new CalDateTime(2025, 01, 04, 0, 0, 0, CalDateTime.UtcTzId);
+        var from = new CalDateTime(2025, 01, 01, 0, 0, 0, CalDateTime.UtcTzId).ToZonedDateTime();
+        var to = new CalDateTime(2025, 01, 04, 0, 0, 0, CalDateTime.UtcTzId).ToZonedDateTime().ToInstant();
 
         var occurrences = cal.GetOccurrences(from).TakeWhileBefore(to).ToList();
 
@@ -4773,8 +4457,116 @@ public void GetOccurrences_WithMultipleOverridesForSameRecurrenceId_ShouldUseLat
             new CalDateTime(2025, 01, 01, 10, 0, 0, CalDateTime.UtcTzId),
             new CalDateTime(2025, 01, 02, 12, 0, 0, CalDateTime.UtcTzId),
             new CalDateTime(2025, 01, 03, 10, 0, 0, CalDateTime.UtcTzId),
-        };
+        }.Select(x => x.ToZonedDateTime()).ToList();
+
+        Assert.That(occurrences.Select(o => o.Start).ToArray(), Is.EqualTo(expected));
+    }
+
+    [TestCase("20251102T040000", "UTC", "FREQ=HOURLY")]
+    [TestCase("20251102", "America/New_York", "FREQ=HOURLY")]
+    [TestCase("20251102", null, "FREQ=HOURLY")]
+    public void GetOccurrences_BackwardsDaylightSaving_25Hours(string start, string? tzId, string rrule)
+    {
+        var evt = new CalendarEvent();
+        evt.RecurrenceRules.Add(new(rrule));
+        evt.Start = new(start, tzId);
+        evt.Duration = Duration.FromHours(1);
+
+        var cal = new Calendar();
+        cal.Events.Add(evt);
+
+        var tz = DateUtil.GetZone("America/New_York");
+        var result = cal.GetOccurrences(tz.AtStartOfDay(new LocalDate(2025, 11, 2)))
+            .TakeWhileBefore(tz.AtStartOfDay(new LocalDate(2025, 11, 3)).ToInstant())
+            .Select(x => x.Start)
+            .ToList();
+
+        var expectedStart = tz.AtStartOfDay(new LocalDate(2025, 11, 2));
+        var expected = new List<ZonedDateTime>();
+        do { expected.Add(expectedStart); }
+        while ((expectedStart = expectedStart.PlusHours(1)).Day == 2);
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [TestCase("20251102T041500", "UTC")]
+    [TestCase("20251102T001500", "America/New_York")]
+    [TestCase("20251102T001500", null)]
+    public void GetOccurrences_BackwardsDaylightSaving_25Hours_Shifted(string start, string? tzId)
+    {
+        var evt = new CalendarEvent();
+        evt.RecurrenceRules.Add(new("FREQ=MINUTELY;INTERVAL=10"));
+        evt.Start = new(start, tzId);
+        evt.Duration = Duration.FromMinutes(10);
+
+        var cal = new Calendar();
+        cal.Events.Add(evt);
+
+        var tz = DateUtil.GetZone("America/New_York");
+        var result = cal.GetOccurrences(tz.AtStrictly(new LocalDateTime(2025, 11, 2, 0, 15)))
+            .TakeWhileBefore(tz.AtStartOfDay(new LocalDate(2025, 11, 3)).ToInstant())
+            .Select(x => x.Period)
+            .ToList();
+
+        var expectedStart = tz.AtStrictly(new LocalDateTime(2025, 11, 2, 0, 15));
+        var expected = new List<(ZonedDateTime, ZonedDateTime)>();
+        do { expected.Add((expectedStart, expectedStart.PlusMinutes(10))); }
+        while ((expectedStart = expectedStart.PlusMinutes(10)).Day == 2);
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [TestCase("20251102T041500", "UTC")]
+    [TestCase("20251102T001500", "America/New_York")]
+    [TestCase("20251102T001500", null)]
+    public void GetOccurrences_BackwardsDaylightSaving_25Hours_NoDuration(string start, string? tzId)
+    {
+        var evt = new CalendarEvent();
+        evt.RecurrenceRules.Add(new("FREQ=MINUTELY;INTERVAL=10"));
+        evt.Start = new(start, tzId);
+        evt.End = evt.Start;
+
+        var cal = new Calendar();
+        cal.Events.Add(evt);
+
+        var tz = DateUtil.GetZone("America/New_York");
+        var result = cal.GetOccurrences(tz.AtStrictly(new LocalDateTime(2025, 11, 2, 0, 15)))
+            .TakeWhileBefore(tz.AtStartOfDay(new LocalDate(2025, 11, 3)).ToInstant())
+            .Select(x => x.Period)
+            .ToList();
+
+        var expectedStart = tz.AtStrictly(new LocalDateTime(2025, 11, 2, 0, 15));
+        var expected = new List<(ZonedDateTime, ZonedDateTime)>();
+        do { expected.Add((expectedStart, expectedStart)); }
+        while ((expectedStart = expectedStart.PlusMinutes(10)).Day == 2);
+
+        Assert.That(result, Is.EqualTo(expected));
+    }
+
+    [TestCase("20251102T041500", "UTC")]
+    [TestCase("20251102T001500", "America/New_York")]
+    [TestCase("20251102T001500", null)]
+    public void GetOccurrences_BackwardsDaylightSaving_SpanFirstHour(string start, string? tzId)
+    {
+        var evt = new CalendarEvent();
+        evt.RecurrenceRules.Add(new("FREQ=MINUTELY;INTERVAL=10"));
+        evt.Start = new(start, tzId);
+        evt.Duration = Duration.FromMinutes(90);
+
+        var cal = new Calendar();
+        cal.Events.Add(evt);
+
+        var tz = DateUtil.GetZone("America/New_York");
+        var result = cal.GetOccurrences(tz.AtStrictly(new LocalDateTime(2025, 11, 2, 0, 15)))
+            .TakeWhileBefore(tz.AtStartOfDay(new LocalDate(2025, 11, 3)).ToInstant())
+            .Select(x => x.Period)
+            .ToList();
+
+        var expectedStart = tz.AtStrictly(new LocalDateTime(2025, 11, 2, 0, 15));
+        var expected = new List<(ZonedDateTime, ZonedDateTime)>();
+        do { expected.Add((expectedStart, expectedStart.PlusMinutes(90))); }
+        while ((expectedStart = expectedStart.PlusMinutes(10)).Day == 2);
 
-        Assert.That(occurrences.Select(o => o.Period.StartTime).ToArray(), Is.EqualTo(expected));
+        Assert.That(result, Is.EqualTo(expected));
     }
 }
diff --git a/Ical.Net.Tests/RecurrenceTests_From_Issues.cs b/Ical.Net.Tests/RecurrenceTests_From_Issues.cs
index 940864590..f5372e6dc 100644
--- a/Ical.Net.Tests/RecurrenceTests_From_Issues.cs
+++ b/Ical.Net.Tests/RecurrenceTests_From_Issues.cs
@@ -11,6 +11,8 @@
 using Ical.Net.CalendarComponents;
 using Ical.Net.DataTypes;
 using Ical.Net.Evaluation;
+using NodaTime;
+using NodaTime.Extensions;
 using NUnit.Framework;
 
 namespace Ical.Net.Tests;
@@ -50,7 +52,8 @@ public void GetOccurrence_DtEnd_ShouldBeExcluded()
 
         var calendar = Calendar.Load(ical)!;
         // Event ends on 2024-10-27, at 02:00:00 GMT (when DST ends). The end time is excluded by RFC 5545 definition.
-        var occurrences = calendar.GetOccurrences(endDate).TakeWhileBefore(new CalDateTime("20250101T000000", "Europe/London")).ToList();
+        var occurrences = calendar.GetOccurrences(endDate.ToZonedDateTime("US/Eastern"))
+            .TakeWhileBefore(new CalDateTime("20250101T000000", "Europe/London")).ToList();
 
         Assert.That(occurrences, Is.Empty);
     }
@@ -77,7 +80,7 @@ public void ClockGoingForwardTest()
         CalDateTime start = new CalDateTime(2025, 3, 30, 0, 0, 0, tzId);
         CalDateTime end = new CalDateTime(2025, 3, 31, 0, 0, 0, tzId);
 
-        var occurrences = calendar.GetOccurrences<CalendarEvent>(start).TakeWhileBefore(end).ToList();
+        var occurrences = calendar.GetOccurrences<CalendarEvent>(start.ToZonedDateTime(tzId)).TakeWhileBefore(end.ToZonedDateTime(tzId).ToInstant()).ToList();
         var occurrence = occurrences.Single();
 
         // Assert
@@ -85,8 +88,8 @@ public void ClockGoingForwardTest()
         {
             Assert.That(occurrences.Count(), Is.EqualTo(1));
             Assert.That(occurrence.Source, Is.SameAs(myEvent));
-            Assert.That(occurrence.Period.StartTime, Is.EqualTo(myEvent.Start));
-            Assert.That(occurrence.Period.EffectiveEndTime, Is.EqualTo(myEvent.End));
+            Assert.That(occurrence.Start, Is.EqualTo(myEvent.Start.ToZonedDateTime(tzId)));
+            Assert.That(occurrence.End, Is.EqualTo(myEvent.End.ToZonedDateTime(tzId)));
         });
     }
 
@@ -111,7 +114,7 @@ public void ClockGoingBackTest()
         CalDateTime start = new CalDateTime(2024, 10, 27, 0, 0, 0, tzId);
         CalDateTime end = new CalDateTime(2024, 10, 28, 0, 0, 0, tzId);
 
-        var occurrences = calendar.GetOccurrences<CalendarEvent>(start).TakeWhileBefore(end).ToList();
+        var occurrences = calendar.GetOccurrences<CalendarEvent>(start.ToZonedDateTime(tzId)).TakeWhileBefore(end.ToZonedDateTime(tzId).ToInstant()).ToList();
         var occurrence = occurrences.Single();
 
         // Assert
@@ -119,8 +122,8 @@ public void ClockGoingBackTest()
         {
             Assert.That(occurrences.Count(), Is.EqualTo(1));
             Assert.That(occurrence.Source, Is.SameAs(myEvent));
-            Assert.That(occurrence.Period.StartTime, Is.EqualTo(myEvent.Start));
-            Assert.That(occurrence.Period.EffectiveEndTime, Is.EqualTo(myEvent.End));
+            Assert.That(occurrence.Start, Is.EqualTo(myEvent.Start.ToZonedDateTime(tzId)));
+            Assert.That(occurrence.End, Is.EqualTo(myEvent.End.ToZonedDateTime(tzId)));
         });
     }
 
@@ -147,7 +150,7 @@ public void ClockGoingForwardAllDayTest()
         CalDateTime start = new CalDateTime(2025, 3, 30, 0, 0, 0, timeZoneId);
         CalDateTime end = new CalDateTime(2025, 3, 31, 0, 0, 0, timeZoneId);
 
-        var occurrences = calendar.GetOccurrences<CalendarEvent>(start).TakeWhileBefore(end).ToList();
+        var occurrences = calendar.GetOccurrences<CalendarEvent>(start.ToZonedDateTime(timeZoneId)).TakeWhileBefore(end.ToZonedDateTime(timeZoneId).ToInstant()).ToList();
         var occurrence = occurrences.Single();
 
         // Assert
@@ -155,10 +158,8 @@ public void ClockGoingForwardAllDayTest()
         {
             Assert.That(occurrences.Count, Is.EqualTo(1));
             Assert.That(occurrence.Source, Is.SameAs(myEvent));
-            Assert.That(occurrence.Period.StartTime.HasTime, Is.False);
-            Assert.That(occurrence.Period.StartTime, Is.EqualTo(myEvent.Start));
-            Assert.That(occurrence.Period.EndTime, Is.Null);
-            Assert.That(occurrence.Period.EffectiveEndTime, Is.EqualTo(myEvent.End));
+            Assert.That(occurrence.Start, Is.EqualTo(myEvent.Start.ToZonedDateTime(timeZoneId)));
+            Assert.That(occurrence.End, Is.EqualTo(myEvent.End.ToZonedDateTime(timeZoneId)));
         });
     }
 
@@ -168,7 +169,7 @@ public void ClockGoingBackAllDayTest()
         // Daylight saving transition bugs #623 
 
         // Arrange
-        var timeZoneId = "GMT Standard Time";
+        var timeZoneId = "GMT";
 
         var myEvent = new CalendarEvent
         {
@@ -186,7 +187,7 @@ public void ClockGoingBackAllDayTest()
         CalDateTime end = new CalDateTime(2024, 10, 28, 0, 0, 0, timeZoneId);
         // Duration can't be used at the same time as End.
 
-        var occurrences = calendar.GetOccurrences<CalendarEvent>(start).TakeWhileBefore(end).ToList();
+        var occurrences = calendar.GetOccurrences<CalendarEvent>(start.ToZonedDateTime(timeZoneId)).TakeWhileBefore(end.ToZonedDateTime(timeZoneId).ToInstant()).ToList();
         var occurrence = occurrences.Single();
 
         // Assert
@@ -194,10 +195,8 @@ public void ClockGoingBackAllDayTest()
         {
             Assert.That(occurrences.Count, Is.EqualTo(1));
             Assert.That(occurrence.Source, Is.SameAs(myEvent));
-            Assert.That(occurrence.Period.StartTime.HasTime, Is.False);
-            Assert.That(occurrence.Period.StartTime, Is.EqualTo(myEvent.Start));
-            Assert.That(occurrence.Period.EndTime, Is.Null);
-            Assert.That(occurrence.Period.EffectiveEndTime, Is.EqualTo(myEvent.End));
+            Assert.That(occurrence.Start, Is.EqualTo(myEvent.Start.ToZonedDateTime(timeZoneId)));
+            Assert.That(occurrence.End, Is.EqualTo(myEvent.End.ToZonedDateTime(timeZoneId)));
         });
     }
 
@@ -223,7 +222,7 @@ public void ClockGoingBackAllDayNonLocalTest()
         CalDateTime start = new CalDateTime(2024, 10, 27, 0, 0, 0, timeZoneId);
         CalDateTime end = new CalDateTime(2024, 10, 28, 0, 0, 0, timeZoneId);
 
-        var occurrences = calendar.GetOccurrences<CalendarEvent>(start).TakeWhileBefore(end).ToList();
+        var occurrences = calendar.GetOccurrences<CalendarEvent>(start.ToZonedDateTime(timeZoneId)).TakeWhileBefore(end.ToZonedDateTime(timeZoneId).ToInstant()).ToList();
         var occurrence = occurrences.Single();
 
         // Assert
@@ -232,10 +231,8 @@ public void ClockGoingBackAllDayNonLocalTest()
             Assert.That(myEvent.IsAllDay, Is.True);
             Assert.That(occurrences.Count, Is.EqualTo(1));
             Assert.That(occurrence.Source, Is.SameAs(myEvent));
-            Assert.That(occurrence.Period.StartTime.HasTime, Is.False);
-            Assert.That(occurrence.Period.StartTime, Is.EqualTo(myEvent.Start));
-            Assert.That(occurrence.Period.EndTime, Is.Null);
-            Assert.That(occurrence.Period.EffectiveEndTime, Is.EqualTo(myEvent.End));
+            Assert.That(occurrence.Start, Is.EqualTo(myEvent.Start.ToZonedDateTime(timeZoneId)));
+            Assert.That(occurrence.End, Is.EqualTo(myEvent.End.ToZonedDateTime(timeZoneId)));
         });
     }
 
@@ -261,7 +258,7 @@ public void ClockGoingForwardAllDayNonLocalTest()
         CalDateTime start = new CalDateTime(2025, 3, 30, 0, 0, 0, timeZoneId);
         CalDateTime end = new CalDateTime(2025, 3, 31, 0, 0, 0, timeZoneId);
 
-        var occurrences = calendar.GetOccurrences<CalendarEvent>(start).TakeWhileBefore(end).ToList();
+        var occurrences = calendar.GetOccurrences<CalendarEvent>(start.ToZonedDateTime(timeZoneId)).TakeWhileBefore(end.ToZonedDateTime(timeZoneId).ToInstant()).ToList();
         var occurrence = occurrences.Single();
 
         // Assert
@@ -270,10 +267,8 @@ public void ClockGoingForwardAllDayNonLocalTest()
             Assert.That(occurrences.Count, Is.EqualTo(1));
             Assert.That(occurrence.Source, Is.SameAs(myEvent));
             Assert.That(myEvent.IsAllDay, Is.True);
-            Assert.That(occurrence.Period.StartTime.HasTime, Is.False);
-            Assert.That(occurrence.Period.StartTime, Is.EqualTo(myEvent.Start));
-            Assert.That(occurrence.Period.EndTime, Is.Null);
-            Assert.That(occurrence.Period.EffectiveEndTime, Is.EqualTo(myEvent.End));
+            Assert.That(occurrence.Start, Is.EqualTo(myEvent.Start.ToZonedDateTime(timeZoneId)));
+            Assert.That(occurrence.End, Is.EqualTo(myEvent.End.ToZonedDateTime(timeZoneId)));
         });
     }
 
@@ -306,7 +301,8 @@ public void CheckCalendarZone()
 
         var start = new CalDateTime(2024, 12, 9, 8, 5, 0, CalDateTime.UtcTzId);
         var end = new CalDateTime(2024, 12, 10, 7, 59, 59, CalDateTime.UtcTzId);
-        var occurrence = calendar.GetOccurrences(start).TakeWhileBefore(end);
+        var occurrence = calendar.GetOccurrences(start.ToZonedDateTime("US/Eastern"))
+            .TakeWhileBefore(end);
 
         Assert.That(occurrence.Count, Is.EqualTo(1));
     }
@@ -362,9 +358,9 @@ private static void CheckDates(DateTime startDate, DateTime endDate, CalDateTime
         };
 
         var occurrences = calendarEvent.GetOccurrences(new CalDateTime(startDate)).TakeWhileBefore(new CalDateTime(endDate));
-        var occurrencesDates = occurrences.Select(o => new CalDateTime(o.Period.StartTime.Date)).ToList();
+        var occurrencesDates = occurrences.Select(o => o.Start.Date).ToList();
 
-        var sortedExpectedDates = expectedDates.ToList();
+        var sortedExpectedDates = expectedDates.Select(x => x.ToZonedDateTime().Date).ToList();
 
         Assert.That(occurrencesDates, Is.EquivalentTo(sortedExpectedDates));
     }
@@ -510,7 +506,7 @@ public void Except_Tuesday_Thursday_Saturday_Sunday()
             // Assert that none of the occurrences contain a weekday from the ByDay list
             foreach (var occurrence in occurrences)
             {
-                Assert.That(excludedDays, Does.Not.Contain(occurrence.Period.StartTime.DayOfWeek));
+                Assert.That(excludedDays, Does.Not.Contain(occurrence.Start.DayOfWeek.ToDayOfWeek()));
             }
         });
     }
@@ -524,11 +520,12 @@ public void Weekly_ByDay_ByMonth()
         var rpe = new RecurrencePatternEvaluator(rp);
 
         var referenceDate = new CalDateTime(2025, 11, 07, 0, 0, 0, "Central Standard Time");
-        var recurringPeriods = rpe.Evaluate(referenceDate, null, null);
+        var start = referenceDate.ToZonedDateTime();
+        var recurringPeriods = rpe.Evaluate(referenceDate, start.Zone, start.ToInstant(), null);
 
-        var result = recurringPeriods.FirstOrDefault()?.StartTime;
+        var result = recurringPeriods.FirstOrDefault()?.Start;
 
-        var expected = new CalDateTime(2026, 05, 01, 0, 0, 0, "Central Standard Time");
+        var expected = new LocalDate(2026, 05, 01).AtStartOfDayInZone(start.Zone);
         Assert.That(result, Is.EqualTo(expected));
     }
 }
diff --git a/Ical.Net.Tests/RecurrenceWithExDateTests.cs b/Ical.Net.Tests/RecurrenceWithExDateTests.cs
index 2df3170d2..af4603bf5 100644
--- a/Ical.Net.Tests/RecurrenceWithExDateTests.cs
+++ b/Ical.Net.Tests/RecurrenceWithExDateTests.cs
@@ -9,6 +9,8 @@
 using Ical.Net.CalendarComponents;
 using Ical.Net.DataTypes;
 using Ical.Net.Serialization;
+using Ical.Net.Utility;
+using NodaTime;
 using NUnit.Framework;
 
 namespace Ical.Net.Tests;
@@ -58,13 +60,13 @@ public void ShouldNotOccurOnLocalExceptionDate(bool useExDateWithTime)
         var ics = serializer.SerializeToString(calendar)!;
 
         var deserializedCalendar = Calendar.Load(ics)!;
-        var occurrences = deserializedCalendar.GetOccurrences<CalendarEvent>().ToList();
+        var occurrences = deserializedCalendar.GetOccurrences<CalendarEvent>(DateUtil.GetZone(timeZoneId)).ToList();
 
         Assert.Multiple(() =>
         {
             if (useExDateWithTime)
             {
-                Assert.That(occurrences.Single().Period, Is.EqualTo(new Period(start, end.Subtract(start))));
+                Assert.That(occurrences.Single().Period, Is.EqualTo((start.ToZonedDateTime(timeZoneId), end.ToZonedDateTime(timeZoneId))));
                 Assert.That(ics, Does.Contain("EXDATE;TZID=Europe/London:20241019T210000"));
             }
             else
@@ -97,7 +99,7 @@ public void ShouldNotOccurOnUtcExceptionDate()
                   """;
 
         var cal = Calendar.Load(ics)!;
-        var occurrences = cal.GetOccurrences<CalendarEvent>().ToList();
+        var occurrences = cal.GetOccurrences<CalendarEvent>(DateUtil.GetZone("GMT")).ToList();
 
         var serializer = new CalendarSerializer();
         ics = serializer.SerializeToString(cal);
@@ -120,7 +122,7 @@ public void ShouldNotOccurOnUtcExceptionDate()
                     o => !cal
                         .Events[0]!
                         .ExceptionDates.GetAllDates()
-                        .Any(ex => ex.Equals(o.Period.StartTime))), Is.True);
+                        .Any(ex => ex.ToInstant().Equals(o.Start.ToInstant()))), Is.True);
             Assert.That(ics, Does.Contain("EXDATE:20241019T190000Z"));
         });
     }
@@ -145,7 +147,7 @@ public void MultipleExclusionDatesSameTimeZoneShouldBeExcluded()
                   """;
 
         var cal = Calendar.Load(ics)!;
-        var occurrences = cal.GetOccurrences<CalendarEvent>().ToList();
+        var occurrences = cal.GetOccurrences<CalendarEvent>(DateUtil.GetZone("Europe/Berlin")).ToList();
 
         var serializer = new CalendarSerializer();
         ics = serializer.SerializeToString(cal);
@@ -179,7 +181,7 @@ public void MultipleExclusionDatesSameTimeZoneShouldBeExcluded()
                     o => !cal
                         .Events[0]!
                         .ExceptionDates.GetAllDates()
-                        .Any(ex => ex.Equals(o.Period.StartTime))), Is.True);
+                        .Any(ex => ex.ToInstant().Equals(o.Start.ToInstant()))), Is.True);
             Assert.That(ics, Does.Contain("EXDATE;TZID=Europe/Berlin:20231029T090000,20231105T090000,20231112T090000"));
         });
     }
@@ -207,7 +209,7 @@ public void MultipleExclusionDatesDifferentZoneShouldBeExcluded()
         var cal = Calendar.Load(ics)!;
         // serialize and deserialize to ensure the exclusion dates de/serialized
         cal = Calendar.Load(new CalendarSerializer(cal).SerializeToString()!)!;
-        var occurrences = cal.GetOccurrences<CalendarEvent>().ToList();
+        var occurrences = cal.GetOccurrences<CalendarEvent>(DateUtil.GetZone("America/New_York")).ToList();
 
         // Occurrences:
         // October 25, 2023, 09:00 AM (EDT, UTC-4)
@@ -232,7 +234,7 @@ public void MultipleExclusionDatesDifferentZoneShouldBeExcluded()
                     o => !cal
                         .Events[0]!
                         .ExceptionDates.GetAllDates()
-                        .Any(ex => ex.Equals(o.Period.StartTime))), Is.True);
+                        .Any(ex => ex.ToInstant().Equals(o.Start.ToInstant()))), Is.True);
         });
     }
 }
diff --git a/Ical.Net.Tests/RecurrenceWithRDateTests.cs b/Ical.Net.Tests/RecurrenceWithRDateTests.cs
index fc2fcab5d..1a16ff20b 100644
--- a/Ical.Net.Tests/RecurrenceWithRDateTests.cs
+++ b/Ical.Net.Tests/RecurrenceWithRDateTests.cs
@@ -4,14 +4,19 @@
 //
 
 #nullable enable
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using Ical.Net.CalendarComponents;
 using Ical.Net.Collections;
 using Ical.Net.DataTypes;
+using Ical.Net.Evaluation;
 using Ical.Net.Serialization;
 using Ical.Net.Utility;
+using NodaTime;
 using NUnit.Framework;
+using Duration = Ical.Net.DataTypes.Duration;
+using Period = Ical.Net.DataTypes.Period;
 
 namespace Ical.Net.Tests;
 
@@ -35,13 +40,13 @@ public void RDate_SingleDateTime_IsProcessedCorrectly()
         var serializer = new CalendarSerializer();
         var ics = serializer.SerializeToString(cal);
 
-        var occurrences = calendarEvent.GetOccurrences().ToList();
+        var occurrences = calendarEvent.GetOccurrences(DateUtil.GetZone("America/New_York")).ToList();
 
         Assert.Multiple(() =>
         {
             Assert.That(occurrences, Has.Count.EqualTo(2));
-            Assert.That(occurrences[0].Period.StartTime, Is.EqualTo(new CalDateTime(2023, 10, 1, 10, 0, 0)));
-            Assert.That(occurrences[1].Period.StartTime, Is.EqualTo(new CalDateTime(2023, 10, 2, 10, 0, 0)));
+            Assert.That(occurrences[0].Start, Is.EqualTo(new CalDateTime(2023, 10, 1, 10, 0, 0).ToZonedDateTime("America/New_York")));
+            Assert.That(occurrences[1].Start, Is.EqualTo(new CalDateTime(2023, 10, 2, 10, 0, 0).ToZonedDateTime("America/New_York")));
             Assert.That(ics, Does.Contain("RDATE:20231002T100000"));
             Assert.That(ics, Does.Contain("DURATION:PT1H"));
         });
@@ -68,13 +73,13 @@ public void RDate_SingleDateOnly_IsProcessedCorrectly()
         var serializer = new CalendarSerializer();
         var ics = serializer.SerializeToString(cal);
 
-        var occurrences = calendarEvent.GetOccurrences().ToList();
+        var occurrences = calendarEvent.GetOccurrences(DateUtil.GetZone("America/New_York")).ToList();
 
         Assert.Multiple(() =>
         {
             Assert.That(occurrences, Has.Count.EqualTo(2));
-            Assert.That(occurrences[0].Period.StartTime, Is.EqualTo(new CalDateTime(2023, 10, 1, 10, 0, 0)));
-            Assert.That(occurrences[1].Period.StartTime, Is.EqualTo(new CalDateTime(2023, 10, 2)));
+            Assert.That(occurrences[0].Start, Is.EqualTo(new CalDateTime(2023, 10, 1, 10, 0, 0).ToZonedDateTime("America/New_York")));
+            Assert.That(occurrences[1].Start, Is.EqualTo(new CalDateTime(2023, 10, 2).ToZonedDateTime("America/New_York")));
             Assert.That(ics, Does.Contain("RDATE;VALUE=DATE:20231002"));
             Assert.That(ics, Does.Not.Contain("DURATION:"));
         });
@@ -103,14 +108,14 @@ public void RDate_MultipleDates_WithTimeZones_AreProcessedCorrectly()
         var serializer = new CalendarSerializer();
         var ics = serializer.SerializeToString(cal);
 
-        var occurrences = calendarEvent.GetOccurrences().ToList();
+        var occurrences = calendarEvent.GetOccurrences(DateUtil.GetZone(tzId)).ToList();
 
         Assert.Multiple(() =>
         {
             Assert.That(occurrences, Has.Count.EqualTo(3));
-            Assert.That(occurrences[0].Period.StartTime, Is.EqualTo(new CalDateTime(2023, 10, 1, 10, 0, 0, tzId)));
-            Assert.That(occurrences[1].Period.StartTime, Is.EqualTo(new CalDateTime(2023, 10, 2, 10, 0, 0, tzId)));
-            Assert.That(occurrences[2].Period.StartTime, Is.EqualTo(new CalDateTime(2023, 10, 3, 10, 0, 0, tzId)));
+            Assert.That(occurrences[0].Start, Is.EqualTo(new CalDateTime(2023, 10, 1, 10, 0, 0, tzId).ToZonedDateTime(tzId)));
+            Assert.That(occurrences[1].Start, Is.EqualTo(new CalDateTime(2023, 10, 2, 10, 0, 0, tzId).ToZonedDateTime(tzId)));
+            Assert.That(occurrences[2].Start, Is.EqualTo(new CalDateTime(2023, 10, 3, 10, 0, 0, tzId).ToZonedDateTime(tzId)));
             Assert.That(ics, Does.Contain("RDATE;TZID=America/New_York:20231002T100000,20231003T100000"));
             Assert.That(ics, Does.Contain("DURATION:PT2H"));
         });
@@ -142,16 +147,16 @@ public void RDate_PeriodsWithTimezone_AreProcessedCorrectly()
         var serializer = new CalendarSerializer();
         var ics = serializer.SerializeToString(cal);
 
-        var occurrences = calendarEvent.GetOccurrences().ToList();
+        var occurrences = calendarEvent.GetOccurrences(DateUtil.GetZone(tzId)).ToList();
 
         Assert.Multiple(() =>
         {
             Assert.That(occurrences, Has.Count.EqualTo(3));
-            Assert.That(occurrences[0].Period.StartTime, Is.EqualTo(new CalDateTime(2023, 10, 1, 10, 0, 0, tzId)));
-            Assert.That(occurrences[1].Period.StartTime, Is.EqualTo(new CalDateTime(2023, 10, 2, 10, 0, 0, tzId)));
-            Assert.That(occurrences[2].Period.StartTime, Is.EqualTo(new CalDateTime(2023, 10, 3, 10, 0, 0, tzId)));
-            Assert.That(occurrences[1].Period.EffectiveDuration, Is.EqualTo(new Duration(hours: 4)));
-            Assert.That(occurrences[2].Period.EffectiveDuration, Is.EqualTo(new Duration(hours: 5)));
+            Assert.That(occurrences[0].Start, Is.EqualTo(new CalDateTime(2023, 10, 1, 10, 0, 0, tzId).ToZonedDateTime(tzId)));
+            Assert.That(occurrences[1].Start, Is.EqualTo(new CalDateTime(2023, 10, 2, 10, 0, 0, tzId).ToZonedDateTime(tzId)));
+            Assert.That(occurrences[2].Start, Is.EqualTo(new CalDateTime(2023, 10, 3, 10, 0, 0, tzId).ToZonedDateTime(tzId)));
+            Assert.That(occurrences[1].End, Is.EqualTo(new CalDateTime(2023, 10, 2, 14, 0, 0, tzId).ToZonedDateTime(tzId)));
+            Assert.That(occurrences[2].End, Is.EqualTo(new CalDateTime(2023, 10, 3, 15, 0, 0, tzId).ToZonedDateTime(tzId)));
             // Line folding is used for long lines
             Assert.That(ics, Does.Contain("RDATE;TZID=America/New_York;VALUE=PERIOD:20231002T100000/PT4H,20231003T1000\r\n 00/PT5H"));
         });
@@ -159,16 +164,16 @@ public void RDate_PeriodsWithTimezone_AreProcessedCorrectly()
         // Deserialization
 
         cal = Calendar.Load(ics)!;
-        occurrences = cal.Events.First().GetOccurrences().ToList();
+        occurrences = cal.Events.First().GetOccurrences(DateUtil.GetZone(tzId)).ToList();
 
         Assert.Multiple(() =>
         {
             Assert.That(occurrences, Has.Count.EqualTo(3));
-            Assert.That(occurrences[0].Period.StartTime, Is.EqualTo(new CalDateTime(2023, 10, 1, 10, 0, 0, tzId)));
-            Assert.That(occurrences[1].Period.StartTime, Is.EqualTo(new CalDateTime(2023, 10, 2, 10, 0, 0, tzId)));
-            Assert.That(occurrences[2].Period.StartTime, Is.EqualTo(new CalDateTime(2023, 10, 3, 10, 0, 0, tzId)));
-            Assert.That(occurrences[1].Period.EffectiveDuration, Is.EqualTo(new Duration(hours: 4)));
-            Assert.That(occurrences[2].Period.EffectiveDuration, Is.EqualTo(new Duration(hours: 5)));
+            Assert.That(occurrences[0].Start, Is.EqualTo(new CalDateTime(2023, 10, 1, 10, 0, 0, tzId).ToZonedDateTime(tzId)));
+            Assert.That(occurrences[1].Start, Is.EqualTo(new CalDateTime(2023, 10, 2, 10, 0, 0, tzId).ToZonedDateTime(tzId)));
+            Assert.That(occurrences[2].Start, Is.EqualTo(new CalDateTime(2023, 10, 3, 10, 0, 0, tzId).ToZonedDateTime(tzId)));
+            Assert.That(occurrences[1].End, Is.EqualTo(new CalDateTime(2023, 10, 2, 14, 0, 0, tzId).ToZonedDateTime(tzId)));
+            Assert.That(occurrences[2].End, Is.EqualTo(new CalDateTime(2023, 10, 3, 15, 0, 0, tzId).ToZonedDateTime(tzId)));
         });
     }
 
@@ -190,15 +195,15 @@ public void RDate_MixedDatesAndPeriods_AreProcessedCorrectly()
         var serializer = new CalendarSerializer();
         var ics = serializer.SerializeToString(cal);
 
-        var occurrences = calendarEvent.GetOccurrences().ToList();
+        var occurrences = calendarEvent.GetOccurrences(DateUtil.GetZone("America/New_York")).ToList();
 
         Assert.Multiple(() =>
         {
             Assert.That(occurrences, Has.Count.EqualTo(3));
-            Assert.That(occurrences[0].Period.StartTime, Is.EqualTo(new CalDateTime(2023, 10, 1, 10, 0, 0)));
-            Assert.That(occurrences[1].Period.StartTime, Is.EqualTo(new CalDateTime(2023, 10, 2, 10, 0, 0)));
-            Assert.That(occurrences[2].Period.StartTime, Is.EqualTo(new CalDateTime(2023, 10, 3, 10, 0, 0)));
-            Assert.That(occurrences[2].Period.EffectiveDuration, Is.EqualTo(new Duration(hours: 3)));
+            Assert.That(occurrences[0].Start, Is.EqualTo(new CalDateTime(2023, 10, 1, 10, 0, 0).ToZonedDateTime("America/New_York")));
+            Assert.That(occurrences[1].Start, Is.EqualTo(new CalDateTime(2023, 10, 2, 10, 0, 0).ToZonedDateTime("America/New_York")));
+            Assert.That(occurrences[2].Start, Is.EqualTo(new CalDateTime(2023, 10, 3, 10, 0, 0).ToZonedDateTime("America/New_York")));
+            Assert.That(occurrences[2].End, Is.EqualTo(new CalDateTime(2023, 10, 3, 13, 0, 0).ToZonedDateTime("America/New_York")));
             Assert.That(ics, Does.Contain("RDATE:20231002T100000"));
             Assert.That(ics, Does.Contain("RDATE;VALUE=PERIOD:20231003T100000/PT3H"));
         });
@@ -226,17 +231,17 @@ public void RDate_DifferentTimeZones_AreProcessedCorrectly()
         var serializer = new CalendarSerializer();
         var ics = serializer.SerializeToString(cal);
 
-        var occurrences = calendarEvent.GetOccurrences().ToList();
+        var occurrences = calendarEvent.GetOccurrences(DateUtil.GetZone("America/New_York")).ToList();
 
         Assert.Multiple(() =>
         {
             Assert.That(occurrences, Has.Count.EqualTo(3));
-            Assert.That(occurrences[0].Period.StartTime,
-                Is.EqualTo(new CalDateTime(2023, 10, 1, 10, 0, 0, "America/New_York")));
-            Assert.That(occurrences[1].Period.StartTime,
-                Is.EqualTo(new CalDateTime(2023, 10, 2, 10, 0, 0, "America/Los_Angeles")));
-            Assert.That(occurrences[2].Period.StartTime,
-                Is.EqualTo(new CalDateTime(2023, 10, 3, 10, 0, 0, "Europe/London")));
+            Assert.That(occurrences[0].Start,
+                Is.EqualTo(new CalDateTime(2023, 10, 1, 10, 0, 0, "America/New_York").ToZonedDateTime("America/New_York")));
+            Assert.That(occurrences[1].Start,
+                Is.EqualTo(new CalDateTime(2023, 10, 2, 10, 0, 0, "America/Los_Angeles").ToZonedDateTime("America/New_York")));
+            Assert.That(occurrences[2].Start,
+                Is.EqualTo(new CalDateTime(2023, 10, 3, 10, 0, 0, "Europe/London").ToZonedDateTime("America/New_York")));
             Assert.That(ics, Does.Contain("RDATE;TZID=America/Los_Angeles:20231002T100000"));
             Assert.That(ics, Does.Contain("RDATE;TZID=Europe/London:20231003T100000"));
         });
@@ -260,15 +265,15 @@ public void RDate_DateOnlyWithDurationAndDateTime_AreProcessedCorrectly()
         var serializer = new CalendarSerializer();
         var ics = serializer.SerializeToString(cal);
 
-        var occurrences = calendarEvent.GetOccurrences().ToList();
+        var occurrences = calendarEvent.GetOccurrences(DateUtil.GetZone("America/New_York")).ToList();
 
         Assert.Multiple(() =>
         {
             Assert.That(occurrences, Has.Count.EqualTo(3));
-            Assert.That(occurrences[0].Period.StartTime, Is.EqualTo(eventStart));
-            Assert.That(occurrences[1].Period.StartTime, Is.EqualTo(new CalDateTime(2023, 10, 2)));
-            Assert.That(occurrences[1].Period.EffectiveDuration, Is.EqualTo(new Duration(days: 1)));
-            Assert.That(occurrences[2].Period.StartTime, Is.EqualTo(new CalDateTime(2023, 10, 3, 10, 0, 0)));
+            Assert.That(occurrences[0].Start, Is.EqualTo(eventStart.ToZonedDateTime("America/New_York")));
+            Assert.That(occurrences[1].Start, Is.EqualTo(new CalDateTime(2023, 10, 2).ToZonedDateTime("America/New_York")));
+            Assert.That(occurrences[1].End, Is.EqualTo(new CalDateTime(2023, 10, 3).ToZonedDateTime("America/New_York")));
+            Assert.That(occurrences[2].Start, Is.EqualTo(new CalDateTime(2023, 10, 3, 10, 0, 0).ToZonedDateTime("America/New_York")));
             Assert.That(ics, Does.Contain("RDATE;VALUE=PERIOD:20231002/P1D"));
             Assert.That(ics, Does.Contain("RDATE:20231003T100000"));
             Assert.That(ics, Does.Contain("DURATION:P2D"));
@@ -297,14 +302,14 @@ public void RDate_OverlappingPeriods_AreProcessedCorrectly()
         var serializer = new CalendarSerializer();
         var ics = serializer.SerializeToString(cal);
 
-        var occurrences = calendarEvent.GetOccurrences().ToList();
+        var occurrences = calendarEvent.GetOccurrences(DateUtil.GetZone("America/New_York")).ToList();
 
         Assert.Multiple(() =>
         {
             Assert.That(occurrences, Has.Count.EqualTo(3));
-            Assert.That(occurrences[0].Period.StartTime, Is.EqualTo(new CalDateTime(2023, 10, 1, 10, 0, 0)));
-            Assert.That(occurrences[1].Period.StartTime, Is.EqualTo(new CalDateTime(2023, 10, 2, 10, 0, 0)));
-            Assert.That(occurrences[2].Period.StartTime, Is.EqualTo(new CalDateTime(2023, 10, 2, 11, 0, 0)));
+            Assert.That(occurrences[0].Start, Is.EqualTo(new CalDateTime(2023, 10, 1, 10, 0, 0).ToZonedDateTime("America/New_York")));
+            Assert.That(occurrences[1].Start, Is.EqualTo(new CalDateTime(2023, 10, 2, 10, 0, 0).ToZonedDateTime("America/New_York")));
+            Assert.That(occurrences[2].Start, Is.EqualTo(new CalDateTime(2023, 10, 2, 11, 0, 0).ToZonedDateTime("America/New_York")));
             Assert.That(ics, Does.Contain("RDATE;VALUE=PERIOD:20231002T100000/PT2H,20231002T110000/PT2H"));
         });
     }
@@ -331,14 +336,14 @@ public void RDate_LargeNumberOfDates_ShouldBeLineFolded()
         var serializer = new CalendarSerializer();
         var ics = serializer.SerializeToString(cal);
 
-        var occurrences = calendarEvent.GetOccurrences().ToList();
+        var occurrences = calendarEvent.GetOccurrences(DateUtil.GetZone("America/New_York")).ToList();
 
         Assert.Multiple(() =>
         {
             Assert.That(occurrences, Has.Count.EqualTo(101)); // Including the original event
             for (var i = 0; i < 101; i++)
             {
-                Assert.That(occurrences[i].Period.StartTime, Is.EqualTo(eventStart.AddDays(i)));
+                Assert.That(occurrences[i].Start, Is.EqualTo(eventStart.AddDays(i).ToZonedDateTime("America/New_York")));
             }
             // First folded line is 75 characters long
             Assert.That(ics, Does.Contain("RDATE:20231002T100000,20231003T100000,20231004T100000,20231005T100000,2023"));
@@ -367,13 +372,13 @@ public void RDate_DuplicateDates_ShouldBeSerializedJustOnce()
         var serializer = new CalendarSerializer();
         var ics = serializer.SerializeToString(cal);
 
-        var occurrences = calendarEvent.GetOccurrences().ToList();
+        var occurrences = calendarEvent.GetOccurrences(DateUtil.GetZone("America/New_York")).ToList();
 
         Assert.Multiple(() =>
         {
             Assert.That(occurrences, Has.Count.EqualTo(2));
-            Assert.That(occurrences[0].Period.StartTime, Is.EqualTo(eventStart));
-            Assert.That(occurrences[1].Period.StartTime, Is.EqualTo(periodDuplicate.StartTime));
+            Assert.That(occurrences[0].Start, Is.EqualTo(eventStart.ToZonedDateTime("America/New_York")));
+            Assert.That(occurrences[1].Start, Is.EqualTo(periodDuplicate.StartTime.ToZonedDateTime("America/New_York")));
 
             Assert.That(ics, Does.Contain("RDATE;VALUE=PERIOD:20231002T100000/PT2H"));
         });
@@ -395,6 +400,11 @@ public void RDate_DateOnly_WithExactDuration_ShouldThrow()
         };
         calendarEvent.RecurrenceDates.AddRange(recurrenceDates);
 
-        Assert.That(() => { _ = calendarEvent.GetOccurrences().ToList(); }, Throws.ArgumentException);
+        void action()
+        {
+            _ = calendarEvent.GetOccurrences(DateUtil.GetZone("America/New_York")).ToList();
+        }
+
+        Assert.That(action, Throws.InstanceOf<EvaluationException>());
     }
 }
diff --git a/Ical.Net.Tests/SerializationTests.cs b/Ical.Net.Tests/SerializationTests.cs
index 1c1011018..dcad14396 100644
--- a/Ical.Net.Tests/SerializationTests.cs
+++ b/Ical.Net.Tests/SerializationTests.cs
@@ -28,7 +28,7 @@ public class SerializationTests
     private static CalendarSerializer GetNewSerializer() => new CalendarSerializer();
     private static string SerializeToString(Calendar c) => GetNewSerializer().SerializeToString(c);
     private static string SerializeToString(CalendarEvent e) => SerializeToString(new Calendar { Events = { e } });
-    private static CalendarEvent GetSimpleEvent() => new CalendarEvent { DtStart = new CalDateTime(_nowTime), Duration = (_later.Value - _nowTime.Value).ToDurationExact() };
+    private static CalendarEvent GetSimpleEvent() => new CalendarEvent { DtStart = _nowTime, Duration = (_later.Value - _nowTime.Value).ToDurationExact() };
     private static Calendar DeserializeCalendar(string s) => Calendar.Load(s);
 
     internal static void CompareComponents(ICalendarComponent cb1, ICalendarComponent cb2)
@@ -473,7 +473,7 @@ public void TestRRuleUntilSerialization()
     {
         var rrule = new RecurrencePattern(FrequencyType.Daily)
         {
-            Until = new CalDateTime(_nowTime.AddDays(7)),
+            Until = _nowTime.AddDays(7),
         };
         const string someTz = "Europe/Volgograd";
         var e = new CalendarEvent
@@ -556,8 +556,8 @@ public void SerializeSubcomponent()
         const string expectedString = "This is an expected string";
         var e = new CalendarEvent
         {
-            Start = new CalDateTime(_nowTime),
-            End = new CalDateTime(_later),
+            Start = _nowTime,
+            End = _later,
             Summary = expectedString,
         };
 
diff --git a/Ical.Net.Tests/SimpleDeserializationTests.cs b/Ical.Net.Tests/SimpleDeserializationTests.cs
index 5c67f41db..eb981586c 100644
--- a/Ical.Net.Tests/SimpleDeserializationTests.cs
+++ b/Ical.Net.Tests/SimpleDeserializationTests.cs
@@ -126,16 +126,6 @@ public void Bug2938007()
             Assert.That(evt.Start.HasTime, Is.True);
             Assert.That(evt.End.HasTime, Is.True);
         });
-
-        foreach (var o in evt.GetOccurrences(new CalDateTime(2010, 1, 17, 0, 0, 0)).TakeWhileBefore(new CalDateTime(2010, 2, 1, 0, 0, 0)))
-        {
-            Assert.Multiple(() =>
-            {
-                Assert.That(o.Period.StartTime.HasTime, Is.EqualTo(true));
-                Assert.That(o.Period.EndTime, Is.Null);
-                Assert.That(o.Period.EffectiveEndTime, Is.Not.Null);
-            });
-        }
     }
 
     /// <summary>
@@ -305,7 +295,9 @@ public void Google1()
 
         CalDateTime dtStart = new CalDateTime(2006, 12, 18);
         CalDateTime dtEnd = new CalDateTime(2006, 12, 23);
-        var occurrences = iCal.GetOccurrences(dtStart).TakeWhileBefore(dtEnd).ToList();
+        var occurrences = iCal.GetOccurrences(dtStart.ToZonedDateTime("America/New_York"))
+            .TakeWhileBefore(dtEnd)
+            .ToList();
 
         var dateTimes = new[]
         {
@@ -314,10 +306,10 @@ public void Google1()
             new CalDateTime(2006, 12, 20, 7, 0, 0, tzId),
             new CalDateTime(2006, 12, 21, 7, 0, 0, tzId),
             new CalDateTime(2006, 12, 22, 7, 0, 0, tzId)
-        };
+        }.Select(x => x.ToZonedDateTime("America/New_York")).ToArray();
 
         for (var i = 0; i < dateTimes.Length; i++)
-            Assert.That(occurrences[i].Period.StartTime, Is.EqualTo(dateTimes[i]), "Event should occur at " + dateTimes[i]);
+            Assert.That(occurrences[i].Start, Is.EqualTo(dateTimes[i]), "Event should occur at " + dateTimes[i]);
 
         Assert.That(occurrences, Has.Count.EqualTo(dateTimes.Length), "There should be exactly " + dateTimes.Length + " occurrences; there were " + occurrences.Count);
     }
@@ -450,7 +442,8 @@ public void Language4()
     public void Outlook2007_LineFolds1()
     {
         var iCal = SimpleDeserializer.Default.Deserialize(new StringReader(IcsFiles.Outlook2007LineFolds)).Cast<Calendar>().Single();
-        var events = iCal.GetOccurrences(new CalDateTime(2009, 06, 20)).TakeWhileBefore(new CalDateTime(2009, 06, 22)).ToList();
+        var events = iCal.GetOccurrences(new CalDateTime(2009, 06, 20).ToZonedDateTime("US/Eastern"))
+            .TakeWhileBefore(new CalDateTime(2009, 06, 22)).ToList();
         Assert.That(events, Has.Count.EqualTo(1));
     }
 
@@ -459,7 +452,9 @@ public void Outlook2007_LineFolds2()
     {
         var longName = "The Exceptionally Long Named Meeting Room Whose Name Wraps Over Several Lines When Exported From Leading Calendar and Office Software Application Microsoft Office 2007";
         var iCal = SimpleDeserializer.Default.Deserialize(new StringReader(IcsFiles.Outlook2007LineFolds)).Cast<Calendar>().Single();
-        var events = iCal.GetOccurrences<CalendarEvent>(new CalDateTime(2009, 06, 20)).TakeWhileBefore(new CalDateTime(2009, 06, 22)).ToList();
+        var events = iCal.GetOccurrences<CalendarEvent>(new CalDateTime(2009, 06, 20).ToZonedDateTime("America/New_York"))
+            .TakeWhileBefore(new CalDateTime(2009, 06, 22).ToZonedDateTime("America/New_York").ToInstant())
+            .ToList();
         Assert.That(((CalendarEvent)events[0].Source).Location, Is.EqualTo(longName));
     }
 
diff --git a/Ical.Net.Tests/TestExtensions.cs b/Ical.Net.Tests/TestExtensions.cs
new file mode 100644
index 000000000..554ee317b
--- /dev/null
+++ b/Ical.Net.Tests/TestExtensions.cs
@@ -0,0 +1,39 @@
+//
+// Copyright ical.net project maintainers and contributors.
+// Licensed under the MIT license.
+//
+
+#nullable enable
+using System.Collections.Generic;
+using System.Linq;
+using Ical.Net.CalendarComponents;
+using Ical.Net.DataTypes;
+using Ical.Net.Evaluation;
+using Ical.Net.Utility;
+using NodaTime;
+
+
+namespace Ical.Net.Tests;
+internal static class TestExtensions
+{
+    public static IEnumerable<Occurrence> GetOccurrences(this CalendarEvent calendarEvent, CalDateTime dateTime, EvaluationOptions? options = null)
+    {
+        return calendarEvent.GetOccurrences(dateTime.ToZonedDateTime("America/New_York"), options);
+    }
+
+    public static IEnumerable<Occurrence> TakeWhileBefore(this IEnumerable<Occurrence> sequence, CalDateTime periodEnd)
+        => sequence.TakeWhile(p => p.Start.ToInstant() < periodEnd.ToZonedDateTime("America/New_York").ToInstant());
+
+    public static IEnumerable<EvaluationPeriod> TakeWhileBefore(this IEnumerable<EvaluationPeriod> sequence, CalDateTime periodEnd)
+        => sequence.TakeWhile(p => p.Start.ToInstant() < periodEnd.ToZonedDateTime("America/New_York").ToInstant());
+
+    public static IEnumerable<EvaluationPeriod> Evaluate(this RecurrencePatternEvaluator evaluator, CalDateTime referenceDate, CalDateTime periodStart, EvaluationOptions? options)
+    {
+        return evaluator.Evaluate(referenceDate, periodStart.ToZonedDateTime("America/New_York"), options);
+    }
+
+    public static ZonedDateTime InZoneLeniently(this LocalDateTime value, string zoneId)
+    {
+        return value.InZoneLeniently(DateUtil.GetZone(zoneId));
+    }
+}
diff --git a/Ical.Net.Tests/TestHelpers/OccurrenceTester.cs b/Ical.Net.Tests/TestHelpers/OccurrenceTester.cs
index 94316e965..0c86c5067 100644
--- a/Ical.Net.Tests/TestHelpers/OccurrenceTester.cs
+++ b/Ical.Net.Tests/TestHelpers/OccurrenceTester.cs
@@ -3,28 +3,36 @@
 // Licensed under the MIT license.
 //
 #nullable enable
+using System;
 using System.Linq;
 using Ical.Net.DataTypes;
+using Ical.Net.Evaluation;
+using Ical.Net.Utility;
+using NodaTime;
 using NUnit.Framework;
 
 namespace Ical.Net.Tests.TestHelpers;
 
 internal static class OccurrenceTester
 {
+    private const string _tzid = "US-Eastern";
+
     public static void AssertOccurrences(
         Calendar cal,
         CalDateTime? fromDate,
         CalDateTime? toDate,
-        Period[] expectedPeriods,
-        string[]? timeZones,
-        int eventIndex
-    )
+        DataTypes.Period[] expectedPeriods,
+        int eventIndex,
+        string? timeZone = null)
     {
         var evt = cal.Events.Skip(eventIndex).First();
 
+        var tz = DateUtil.GetZone(timeZone ?? _tzid);
+        var start = fromDate?.ToZonedDateTime(tz).ToInstant();
+
         var occurrences = toDate == null
-            ? evt.GetOccurrences(fromDate).ToList()
-            : evt.GetOccurrences(fromDate).TakeWhileBefore(toDate).ToList();
+            ? evt.GetOccurrences(tz, start).ToList()
+            : evt.GetOccurrences(tz, start).TakeWhileBefore(toDate.ToZonedDateTime(tz).ToInstant()).ToList();
 
         Assert.Multiple(() =>
         {
@@ -40,14 +48,28 @@ int eventIndex
 
             for (var i = 0; i < expectedPeriods.Length; i++)
             {
-                var period = new Period(expectedPeriods[i].StartTime, expectedPeriods[i].EffectiveDuration!.Value);
+                var start = expectedPeriods[i].StartTime.ToZonedDateTime(tz);
 
-                Assert.That(occurrences[i].Period, Is.EqualTo(period), "Event should occur on " + period);
-                if (timeZones != null)
+                ZonedDateTime end;
+
+                if (expectedPeriods[i].Duration is { } d)
+                {
+                    end = start.LocalDateTime
+                        .Plus(d.GetNominalPart())
+                        .InZoneRelativeTo(start)
+                        .Plus(d.GetTimePart());
+                }
+                else if (expectedPeriods[i].EndTime is { } periodEnd)
+                {
+                    end = periodEnd.ToZonedDateTime(tz);
+                }
+                else
                 {
-                    Assert.That(period.StartTime.TimeZoneName, Is.EqualTo(timeZones[i]),
-                        $"Event {period} should occur in the {timeZones[i]} timezone");
+                    throw new Exception("Expected test period must have a duration or an end");
                 }
+
+                Assert.That(occurrences[i].Start, Is.EqualTo(start), "Event should start on " + start);
+                Assert.That(occurrences[i].End, Is.EqualTo(end), "Event should end on " + end);
             }
         });
     }
diff --git a/Ical.Net.Tests/TodoTest.cs b/Ical.Net.Tests/TodoTest.cs
index 239b98cf8..4fa68b646 100644
--- a/Ical.Net.Tests/TodoTest.cs
+++ b/Ical.Net.Tests/TodoTest.cs
@@ -16,7 +16,7 @@ namespace Ical.Net.Tests;
 [TestFixture]
 public class TodoTest
 {
-    private const string _tzid = "US-Eastern";
+    private const string _tzid = "America/New_York";
 
     [Test, TestCaseSource(nameof(ActiveTodo_TestCases)), Category("Todo")]
     public void ActiveTodo_Tests(string calendarString, IList<KeyValuePair<CalDateTime, bool>> incoming)
@@ -27,7 +27,7 @@ public void ActiveTodo_Tests(string calendarString, IList<KeyValuePair<CalDateTi
 
         foreach (var calDateTime in incoming)
         {
-            var dt = new CalDateTime(calDateTime.Key.Date, calDateTime.Key.Time, _tzid);
+            var dt = new CalDateTime(calDateTime.Key.Date, calDateTime.Key.Time, _tzid).ToZonedDateTime(_tzid);
             Assert.That(todo[0].IsActive(dt), Is.EqualTo(calDateTime.Value));
         }
     }
@@ -176,7 +176,7 @@ public void CompletedTodo_Tests(string calendarString, IList<KeyValuePair<CalDat
 
         foreach (var calDateTime in incoming)
         {
-            var dt = new CalDateTime(calDateTime.Key.Date, calDateTime.Key.Time, _tzid);
+            var dt = new CalDateTime(calDateTime.Key.Date, calDateTime.Key.Time, _tzid).ToZonedDateTime(_tzid);
             Assert.That(todo[0].IsCompleted(dt), Is.EqualTo(calDateTime.Value));
         }
     }
@@ -210,11 +210,11 @@ public void Todo7_1()
             new CalDateTime(2007, 2, 2, 9, 0, 0, _tzid),
             new CalDateTime(2007, 3, 2, 9, 0, 0, _tzid),
             new CalDateTime(2007, 4, 6, 9, 0, 0, _tzid)
-        };
+        }.Select(x => x.ToZonedDateTime(_tzid)).ToList();
 
         var occurrences = todo[0].GetOccurrences(
-            new CalDateTime(2006, 7, 1, 9, 0, 0))
-            .TakeWhileBefore(new CalDateTime(2007, 7, 1, 9, 0, 0)).ToList();
+            new CalDateTime(2006, 7, 1, 9, 0, 0).ToZonedDateTime(_tzid))
+            .TakeWhileBefore(new CalDateTime(2007, 7, 1, 9, 0, 0).ToZonedDateTime(_tzid).ToInstant()).ToList();
 
         Assert.That(
             occurrences,
@@ -234,10 +234,9 @@ public void Todo_WithFutureStart_AndNoDuration_ShouldSucceed()
 
         // periodStart is in the future, so filtering the first occurrence will also require
         // looking at the todo's duration, which is unset/null. It must therefore be ignored.
-        var firstOccurrence = todo.GetOccurrences(today.AddDays(2)).FirstOrDefault();
+        var firstOccurrence = todo.GetOccurrences(today.AddDays(2).ToZonedDateTime("America/New_York")).FirstOrDefault();
 
         Assert.That(firstOccurrence, Is.Not.Null);
-        Assert.That(firstOccurrence.Period.StartTime, Is.Not.Null);
-        Assert.That(firstOccurrence.Period.Duration, Is.Null);
+        Assert.That(firstOccurrence.Start, Is.EqualTo(firstOccurrence.End));
     }
 }
diff --git a/Ical.Net.Tests/WikiSamples/RecurrenceWikiTests.cs b/Ical.Net.Tests/WikiSamples/RecurrenceWikiTests.cs
index 12af965dc..505d6f4d3 100644
--- a/Ical.Net.Tests/WikiSamples/RecurrenceWikiTests.cs
+++ b/Ical.Net.Tests/WikiSamples/RecurrenceWikiTests.cs
@@ -13,6 +13,7 @@
 using Ical.Net.Serialization;
 using Ical.Net.Tests.Logging;
 using Microsoft.Extensions.Logging;
+using NodaTime;
 using NUnit.Framework;
 
 namespace Ical.Net.Tests.WikiSamples;
@@ -72,7 +73,8 @@ public void Introduction()
         };
 
         // Get all occurrences of the series.
-        IEnumerable<Occurrence> allOccurrences = calendarEvent.GetOccurrences();
+        var tz = TimeZoneResolvers.Default("UTC");
+        IEnumerable<Occurrence> allOccurrences = calendarEvent.GetOccurrences(tz);
         Assert.That(allOccurrences.Count(), Is.EqualTo(5));
 
         // Wiki code end
@@ -80,21 +82,16 @@ public void Introduction()
         const string expectedOccurrences =
             """
             5 occurrences:
-            Start: 07/10/2025
-              Period: P1D
-              End: 07/11/2025
-            Start: 07/12/2025
-              Period: P1D
-              End: 07/13/2025
-            Start: 07/14/2025
-              Period: P1D
-              End: 07/15/2025
-            Start: 07/16/2025
-              Period: P1D
-              End: 07/17/2025
-            Start: 07/18/2025
-              Period: P1D
-              End: 07/19/2025
+            Start: 2025-07-10T00:00:00 UTC (+00)
+              End: 2025-07-11T00:00:00 UTC (+00)
+            Start: 2025-07-12T00:00:00 UTC (+00)
+              End: 2025-07-13T00:00:00 UTC (+00)
+            Start: 2025-07-14T00:00:00 UTC (+00)
+              End: 2025-07-15T00:00:00 UTC (+00)
+            Start: 2025-07-16T00:00:00 UTC (+00)
+              End: 2025-07-17T00:00:00 UTC (+00)
+            Start: 2025-07-18T00:00:00 UTC (+00)
+              End: 2025-07-19T00:00:00 UTC (+00)
             """;
 
         var generatedOccurrences = ToWikiPeriodString(allOccurrences);
@@ -135,7 +132,8 @@ public void DailyIntervalCount()
         var generatedIcs = calendarSerializer.SerializeToString(calendar);
 
         // Calculate all occurrences
-        IEnumerable<Occurrence> occurrences = calendar.GetOccurrences();
+        var tz = TimeZoneResolvers.Default("Europe/Zurich");
+        IEnumerable<Occurrence> occurrences = calendar.GetOccurrences(tz);
         Assert.That(occurrences.Count(), Is.EqualTo(2));
 
         // Wiki code end
@@ -155,12 +153,10 @@ public void DailyIntervalCount()
         const string expectedOccurrences =
             """
             2 occurrences:
-            Start: 07/10/2025 09:00:00 +02:00 Europe/Zurich
-              Period: PT1H
-              End: 07/10/2025 10:00:00 +02:00 Europe/Zurich
-            Start: 07/12/2025 09:00:00 +02:00 Europe/Zurich
-              Period: PT1H
-              End: 07/12/2025 10:00:00 +02:00 Europe/Zurich
+            Start: 2025-07-10T09:00:00 Europe/Zurich (+02)
+              End: 2025-07-10T10:00:00 Europe/Zurich (+02)
+            Start: 2025-07-12T09:00:00 Europe/Zurich (+02)
+              End: 2025-07-12T10:00:00 Europe/Zurich (+02)
             """;
         
         // Non-Wiki Asserts
@@ -208,7 +204,8 @@ public void YearlyByMonthDayUntil()
         var generatedIcs = calendarSerializer.SerializeToString(calendar);
 
         // Calculate all occurrences
-        IEnumerable<Occurrence> occurrences = calendar.GetOccurrences();
+        var tz = TimeZoneResolvers.Default("Europe/Zurich");
+        IEnumerable<Occurrence> occurrences = calendar.GetOccurrences(tz);
 
         // Wiki code end
 
@@ -227,21 +224,16 @@ public void YearlyByMonthDayUntil()
         const string expectedOccurrences =
             """
             5 occurrences:
-            Start: 07/10/2025 09:00:00 +02:00 Europe/Zurich
-              Period: PT1H
-              End: 07/10/2025 10:00:00 +02:00 Europe/Zurich
-            Start: 07/12/2025 09:00:00 +02:00 Europe/Zurich
-              Period: PT1H
-              End: 07/12/2025 10:00:00 +02:00 Europe/Zurich
-            Start: 07/10/2026 09:00:00 +02:00 Europe/Zurich
-              Period: PT1H
-              End: 07/10/2026 10:00:00 +02:00 Europe/Zurich
-            Start: 07/12/2026 09:00:00 +02:00 Europe/Zurich
-              Period: PT1H
-              End: 07/12/2026 10:00:00 +02:00 Europe/Zurich
-            Start: 07/10/2027 09:00:00 +02:00 Europe/Zurich
-              Period: PT1H
-              End: 07/10/2027 10:00:00 +02:00 Europe/Zurich
+            Start: 2025-07-10T09:00:00 Europe/Zurich (+02)
+              End: 2025-07-10T10:00:00 Europe/Zurich (+02)
+            Start: 2025-07-12T09:00:00 Europe/Zurich (+02)
+              End: 2025-07-12T10:00:00 Europe/Zurich (+02)
+            Start: 2026-07-10T09:00:00 Europe/Zurich (+02)
+              End: 2026-07-10T10:00:00 Europe/Zurich (+02)
+            Start: 2026-07-12T09:00:00 Europe/Zurich (+02)
+              End: 2026-07-12T10:00:00 Europe/Zurich (+02)
+            Start: 2027-07-10T09:00:00 Europe/Zurich (+02)
+              End: 2027-07-10T10:00:00 Europe/Zurich (+02)
             """;
 
         // Non-Wiki Asserts
@@ -291,7 +283,8 @@ public void MonthlyByDayCountRDate()
         var generatedIcs = calendarSerializer.SerializeToString(calendar);
 
         // Calculate all occurrences
-        IEnumerable<Occurrence> occurrences = calendar.GetOccurrences();
+        var tz = TimeZoneResolvers.Default("Europe/Zurich");
+        IEnumerable<Occurrence> occurrences = calendar.GetOccurrences(tz);
 
         // Wiki code end
 
@@ -311,18 +304,14 @@ public void MonthlyByDayCountRDate()
         const string expectedOccurrences =
             """
             4 occurrences:
-            Start: 06/29/2025 16:00:00 +02:00 Europe/Zurich
-              Period: PT4H
-              End: 06/29/2025 20:00:00 +02:00 Europe/Zurich
-            Start: 07/10/2025 09:00:00 +02:00 Europe/Zurich
-              Period: PT4H
-              End: 07/10/2025 13:00:00 +02:00 Europe/Zurich
-            Start: 07/27/2025 16:00:00 +02:00 Europe/Zurich
-              Period: PT4H
-              End: 07/27/2025 20:00:00 +02:00 Europe/Zurich
-            Start: 08/31/2025 16:00:00 +02:00 Europe/Zurich
-              Period: PT4H
-              End: 08/31/2025 20:00:00 +02:00 Europe/Zurich
+            Start: 2025-06-29T16:00:00 Europe/Zurich (+02)
+              End: 2025-06-29T20:00:00 Europe/Zurich (+02)
+            Start: 2025-07-10T09:00:00 Europe/Zurich (+02)
+              End: 2025-07-10T13:00:00 Europe/Zurich (+02)
+            Start: 2025-07-27T16:00:00 Europe/Zurich (+02)
+              End: 2025-07-27T20:00:00 Europe/Zurich (+02)
+            Start: 2025-08-31T16:00:00 Europe/Zurich (+02)
+              End: 2025-08-31T20:00:00 Europe/Zurich (+02)
             """;
 
         // Non-Wiki Asserts
@@ -369,7 +358,8 @@ public void HourlyUntilExDate()
         var generatedIcs = calendarSerializer.SerializeToString(calendar);
 
         // Calculate all occurrences
-        IEnumerable<Occurrence> occurrences = calendar.GetOccurrences();
+        var tz = TimeZoneResolvers.Default("UTC");
+        IEnumerable<Occurrence> occurrences = calendar.GetOccurrences(tz);
 
         // Wiki code end
 
@@ -389,18 +379,14 @@ public void HourlyUntilExDate()
         const string expectedOccurrences =
             """
             4 occurrences:
-            Start: 07/10/2025 20:00:00 +00:00 UTC
-              Period: PT15M
-              End: 07/10/2025 20:15:00 +00:00 UTC
-            Start: 07/10/2025 21:00:00 +00:00 UTC
-              Period: PT15M
-              End: 07/10/2025 21:15:00 +00:00 UTC
-            Start: 07/10/2025 23:00:00 +00:00 UTC
-              Period: PT15M
-              End: 07/10/2025 23:15:00 +00:00 UTC
-            Start: 07/11/2025 00:00:00 +00:00 UTC
-              Period: PT15M
-              End: 07/11/2025 00:15:00 +00:00 UTC
+            Start: 2025-07-10T20:00:00 UTC (+00)
+              End: 2025-07-10T20:15:00 UTC (+00)
+            Start: 2025-07-10T21:00:00 UTC (+00)
+              End: 2025-07-10T21:15:00 UTC (+00)
+            Start: 2025-07-10T23:00:00 UTC (+00)
+              End: 2025-07-10T23:15:00 UTC (+00)
+            Start: 2025-07-11T00:00:00 UTC (+00)
+              End: 2025-07-11T00:15:00 UTC (+00)
             """;
 
         // Non-Wiki Asserts
@@ -468,7 +454,8 @@ public void DailyIntervalCountMoved()
         var generatedIcs = calendarSerializer.SerializeToString(calendar);
 
         // Calculate all occurrences
-        IEnumerable<Occurrence> occurrences = calendar.GetOccurrences();
+        var tz = TimeZoneResolvers.Default("Europe/Zurich");
+        IEnumerable<Occurrence> occurrences = calendar.GetOccurrences(tz);
 
         // Wiki code end
 
@@ -498,18 +485,14 @@ public void DailyIntervalCountMoved()
         const string expectedOccurrences =
             """
             4 occurrences:
-            Start: 07/10/2025 09:00:00 +02:00 Europe/Zurich
-              Period: PT1H
-              End: 07/10/2025 10:00:00 +02:00 Europe/Zurich
-            Start: 07/12/2025 09:00:00 +02:00 Europe/Zurich
-              Period: PT1H
-              End: 07/12/2025 10:00:00 +02:00 Europe/Zurich
-            Start: 07/13/2025 13:00:00 +02:00 Europe/Zurich
-              Period: PT13M
-              End: 07/13/2025 13:13:00 +02:00 Europe/Zurich
-            Start: 07/16/2025 09:00:00 +02:00 Europe/Zurich
-              Period: PT1H
-              End: 07/16/2025 10:00:00 +02:00 Europe/Zurich
+            Start: 2025-07-10T09:00:00 Europe/Zurich (+02)
+              End: 2025-07-10T10:00:00 Europe/Zurich (+02)
+            Start: 2025-07-12T09:00:00 Europe/Zurich (+02)
+              End: 2025-07-12T10:00:00 Europe/Zurich (+02)
+            Start: 2025-07-13T13:00:00 Europe/Zurich (+02)
+              End: 2025-07-13T13:13:00 Europe/Zurich (+02)
+            Start: 2025-07-16T09:00:00 Europe/Zurich (+02)
+              End: 2025-07-16T10:00:00 Europe/Zurich (+02)
             """;
         
         // Non-Wiki Asserts
@@ -553,7 +536,8 @@ public void RecurrenceWithTimeZoneChanges()
         var generatedIcs = calendarSerializer.SerializeToString(calendar);
 
         // Calculate all occurrences
-        IEnumerable<Occurrence> occurrences = calendar.GetOccurrences();
+        var tz = TimeZoneResolvers.Default("Europe/Zurich");
+        IEnumerable<Occurrence> occurrences = calendar.GetOccurrences(tz);
 
         // Wiki code end
 
@@ -572,15 +556,12 @@ public void RecurrenceWithTimeZoneChanges()
         const string expectedOccurrences =
             """
             3 occurrences:
-            Start: 03/24/2025 09:00:00 +01:00 Europe/Zurich
-              Period: PT1H
-              End: 03/24/2025 10:00:00 +01:00 Europe/Zurich
-            Start: 03/31/2025 09:00:00 +02:00 Europe/Zurich
-              Period: PT1H
-              End: 03/31/2025 10:00:00 +02:00 Europe/Zurich
-            Start: 04/07/2025 09:00:00 +02:00 Europe/Zurich
-              Period: PT1H
-              End: 04/07/2025 10:00:00 +02:00 Europe/Zurich
+            Start: 2025-03-24T09:00:00 Europe/Zurich (+01)
+              End: 2025-03-24T10:00:00 Europe/Zurich (+01)
+            Start: 2025-03-31T09:00:00 Europe/Zurich (+02)
+              End: 2025-03-31T10:00:00 Europe/Zurich (+02)
+            Start: 2025-04-07T09:00:00 Europe/Zurich (+02)
+              End: 2025-04-07T10:00:00 Europe/Zurich (+02)
             """;
 
         // Non-Wiki Asserts
@@ -618,9 +599,10 @@ public void GetFirstOccurrenceOfAllCalendarEvents()
             End = start.AddYears(10).AddHours(1)
         });
         
+        var tz = TimeZoneResolvers.Default("UTC");
         var occurrences =
             calendar.Events
-                .SelectMany(ev => ev.GetOccurrences().Take(1))
+                .SelectMany(ev => ev.GetOccurrences(tz).Take(1))
                 .ToArray();
 
         // Wiki code end
@@ -629,12 +611,10 @@ public void GetFirstOccurrenceOfAllCalendarEvents()
         const string expectedOccurrences =
             """
             2 occurrences:
-            Start: 09/01/2025 10:00:00 +00:00 UTC
-              Period: PT1H
-              End: 09/01/2025 11:00:00 +00:00 UTC
-            Start: 09/01/2035 10:00:00 +00:00 UTC
-              Period: PT1H
-              End: 09/01/2035 11:00:00 +00:00 UTC
+            Start: 2025-09-01T10:00:00 UTC (+00)
+              End: 2025-09-01T11:00:00 UTC (+00)
+            Start: 2035-09-01T10:00:00 UTC (+00)
+              End: 2035-09-01T11:00:00 UTC (+00)
             """;
 
         // Non-Wiki Asserts
diff --git a/Ical.Net/Calendar.cs b/Ical.Net/Calendar.cs
index e753ecd35..dae957300 100644
--- a/Ical.Net/Calendar.cs
+++ b/Ical.Net/Calendar.cs
@@ -15,6 +15,7 @@
 using Ical.Net.Proxies;
 using Ical.Net.Serialization;
 using Ical.Net.Utility;
+using NodaTime;
 
 namespace Ical.Net;
 
@@ -179,19 +180,29 @@ public VTimeZone AddTimeZone(VTimeZone tz)
         return tz;
     }
 
-    /// <inheritdoc/>
-    public virtual IEnumerable<Occurrence> GetOccurrences(CalDateTime? startTime = null, EvaluationOptions? options = null)
-        => GetOccurrences<IRecurringComponent>(startTime, options);
+    public virtual IEnumerable<Occurrence> GetOccurrences(ZonedDateTime startTime, EvaluationOptions? options = null)
+    {
+        return GetOccurrences<IRecurringComponent>(startTime, options);
+    }
+
+    public virtual IEnumerable<Occurrence> GetOccurrences(DateTimeZone timeZone, Instant? startTime = null, EvaluationOptions? options = null)
+    {
+        return GetOccurrences<IRecurringComponent>(timeZone, startTime, options);
+    }
+
+    public virtual IEnumerable<Occurrence> GetOccurrences<T>(ZonedDateTime startTime, EvaluationOptions? options = null) where T : IRecurringComponent
+    {
+        return GetOccurrences<T>(startTime.Zone, startTime.ToInstant(), options);
+    }
 
-    /// <inheritdoc/>
-    public virtual IEnumerable<Occurrence> GetOccurrences<T>(CalDateTime? startTime = null, EvaluationOptions? options = null) where T : IRecurringComponent
+    public virtual IEnumerable<Occurrence> GetOccurrences<T>(DateTimeZone timeZone, Instant? startTime = null, EvaluationOptions? options = null) where T : IRecurringComponent
     {
         // Get UID/RECURRENCE-ID combinations that replace occurrences
         var recurrenceIdsAndUids = GetRecurrenceIdsAndUids(Children);
 
         var occurrences = RecurringItems
             .OfType<T>()
-            .Select(recurrable => recurrable.GetOccurrences(startTime, options)
+            .Select(recurrable => recurrable.GetOccurrences(timeZone, startTime, options)
                 // Exclude occurrences that are overridden by other components with the same UID and RECURRENCE-ID.
                 // This must happen before .OrderedDistinct() because that method would remove duplicates
                 // based on the occurrence time, and we need to remove them based on UID + RECURRENCE-ID.
@@ -262,7 +273,7 @@ private static bool IsUnmodifiedOccurrence(Occurrence r, Dictionary<(string? Uid
             // - It is not a unique component, or
             // - There is no replacement for this UID/StartTime in recurrenceIdsAndUids
             IUniqueComponent uc =>
-                !recurrenceIdsAndUids.ContainsKey((uc.Uid, r.Period.StartTime.Value)),
+                !recurrenceIdsAndUids.ContainsKey((uc.Uid, r.DtStart?.Value ?? default)),
 
             // If not a unique component, always keep
             _ => true
@@ -329,13 +340,13 @@ public virtual void MergeWith(IMergeable obj)
         }
     }
 
-    public virtual FreeBusy? GetFreeBusy(FreeBusy freeBusyRequest) => CalendarComponents.FreeBusy.Create(this, freeBusyRequest);
+    public virtual FreeBusy? GetFreeBusy(DateTimeZone timeZone, FreeBusy freeBusyRequest) => CalendarComponents.FreeBusy.Create(this, timeZone, freeBusyRequest);
 
-    public virtual FreeBusy? GetFreeBusy(CalDateTime fromInclusive, CalDateTime toExclusive)
-        => CalendarComponents.FreeBusy.Create(this, CalendarComponents.FreeBusy.CreateRequest(fromInclusive, toExclusive, null, null));
+    public virtual FreeBusy? GetFreeBusy(DateTimeZone timeZone, CalDateTime fromInclusive, CalDateTime toExclusive)
+        => CalendarComponents.FreeBusy.Create(this, timeZone, CalendarComponents.FreeBusy.CreateRequest(fromInclusive, toExclusive, null, null));
 
-    public virtual FreeBusy? GetFreeBusy(Organizer organizer, IEnumerable<Attendee> contacts, CalDateTime fromInclusive, CalDateTime toExclusive)
-        => CalendarComponents.FreeBusy.Create(this, CalendarComponents.FreeBusy.CreateRequest(fromInclusive, toExclusive, organizer, contacts));
+    public virtual FreeBusy? GetFreeBusy(DateTimeZone timeZone, Organizer organizer, IEnumerable<Attendee> contacts, CalDateTime fromInclusive, CalDateTime toExclusive)
+        => CalendarComponents.FreeBusy.Create(this, timeZone, CalendarComponents.FreeBusy.CreateRequest(fromInclusive, toExclusive, organizer, contacts));
 
     /// <summary>
     /// Adds a system time zone to the iCalendar. This time zone may
diff --git a/Ical.Net/CalendarCollection.cs b/Ical.Net/CalendarCollection.cs
index f3304fc3d..b78f0f26c 100644
--- a/Ical.Net/CalendarCollection.cs
+++ b/Ical.Net/CalendarCollection.cs
@@ -13,6 +13,7 @@
 using Ical.Net.Evaluation;
 using Ical.Net.Serialization;
 using Ical.Net.Utility;
+using NodaTime;
 
 namespace Ical.Net;
 
@@ -56,11 +57,15 @@ private IEnumerable<Occurrence> GetOccurrences(Func<Calendar, IEnumerable<Occurr
         // being ordered to avoid full enumeration.
         .OrderedMergeMany();
 
-    public IEnumerable<Occurrence> GetOccurrences(CalDateTime? startTime = null, EvaluationOptions? options = null)
-        => GetOccurrences(iCal => iCal.GetOccurrences(startTime, options));
 
-    public IEnumerable<Occurrence> GetOccurrences<T>(CalDateTime? startTime = null, EvaluationOptions? options = null) where T : IRecurringComponent
-        => GetOccurrences(iCal => iCal.GetOccurrences<T>(startTime, options));
+    public IEnumerable<Occurrence> GetOccurrences(ZonedDateTime startTime, EvaluationOptions? options = null)
+        => GetOccurrences(iCal => iCal.GetOccurrences(startTime.Zone, startTime.ToInstant(), options));
+
+    public IEnumerable<Occurrence> GetOccurrences(DateTimeZone timeZone, Instant? startTime = null, EvaluationOptions? options = null)
+        => GetOccurrences(iCal => iCal.GetOccurrences(timeZone, startTime, options));
+
+    public IEnumerable<Occurrence> GetOccurrences<T>(DateTimeZone timeZone, Instant? startTime = null, EvaluationOptions? options = null) where T : IRecurringComponent
+        => GetOccurrences(iCal => iCal.GetOccurrences<T>(timeZone, startTime, options));
 
     private FreeBusy CombineFreeBusy(FreeBusy? main, FreeBusy current)
     {
@@ -68,20 +73,20 @@ private FreeBusy CombineFreeBusy(FreeBusy? main, FreeBusy current)
         return current;
     }
 
-    public FreeBusy? GetFreeBusy(FreeBusy freeBusyRequest)
+    public FreeBusy? GetFreeBusy(DateTimeZone timeZone, FreeBusy freeBusyRequest)
     {
         return this.Aggregate<Calendar, FreeBusy?>(null, (current, iCal) =>
         {
-            var freeBusy = iCal.GetFreeBusy(freeBusyRequest);
+            var freeBusy = iCal.GetFreeBusy(timeZone, freeBusyRequest);
             return current is null || freeBusy is null ? freeBusy : CombineFreeBusy(current, freeBusy);
         });
     }
 
-    public FreeBusy? GetFreeBusy(Organizer organizer, IEnumerable<Attendee> contacts, CalDateTime fromInclusive, CalDateTime toExclusive)
+    public FreeBusy? GetFreeBusy(DateTimeZone timeZone, Organizer organizer, IEnumerable<Attendee> contacts, CalDateTime fromInclusive, CalDateTime toExclusive)
     {
         return this.Aggregate<Calendar, FreeBusy?>(null, (current, iCal) =>
         {
-            var freeBusy = iCal.GetFreeBusy(organizer, contacts, fromInclusive, toExclusive);
+            var freeBusy = iCal.GetFreeBusy(timeZone, organizer, contacts, fromInclusive, toExclusive);
             return current is null || freeBusy is null ? freeBusy : CombineFreeBusy(current, freeBusy);
         });
     }
diff --git a/Ical.Net/CalendarComponents/Alarm.cs b/Ical.Net/CalendarComponents/Alarm.cs
index b61851036..a8539d1f5 100644
--- a/Ical.Net/CalendarComponents/Alarm.cs
+++ b/Ical.Net/CalendarComponents/Alarm.cs
@@ -3,10 +3,10 @@
 // Licensed under the MIT license.
 //
 
-using System;
 using System.Collections.Generic;
 using Ical.Net.DataTypes;
 using Ical.Net.Evaluation;
+using NodaTime;
 
 namespace Ical.Net.CalendarComponents;
 
@@ -40,9 +40,9 @@ public virtual string? Description
         set => Properties.Set("DESCRIPTION", value);
     }
 
-    public virtual Duration? Duration
+    public virtual DataTypes.Duration? Duration
     {
-        get => Properties.Get<Duration>("DURATION");
+        get => Properties.Get<DataTypes.Duration>("DURATION");
         set => Properties.Set("DURATION", value);
     }
 
@@ -73,7 +73,7 @@ public Alarm()
     /// Gets a list of alarm occurrences for the given recurring component, <paramref name="rc"/>
     /// that occur at or after <paramref name="fromDate"/>.
     /// </summary>
-    public virtual IList<AlarmOccurrence> GetOccurrences(IRecurringComponent rc, CalDateTime? fromDate, EvaluationOptions? options)
+    public virtual IList<AlarmOccurrence> GetOccurrences(IRecurringComponent rc, DateTimeZone timeZone, Instant? fromDate, EvaluationOptions? options)
     {
         if (Trigger == null)
         {
@@ -90,44 +90,32 @@ public virtual IList<AlarmOccurrence> GetOccurrences(IRecurringComponent rc, Cal
             // Ensure that "FromDate" has already been set
             if (fromDate == null)
             {
-                fromDate = rc.Start?.Copy();
+                fromDate = rc.Start?.ToZonedDateTime(timeZone).ToInstant();
             }
 
-            Duration? duration = null;
-            foreach (var o in rc.GetOccurrences(fromDate, options))
+            var triggerDuration = Trigger.Duration!.Value.ToPeriod();
+
+            foreach (var o in rc.GetOccurrences(timeZone, fromDate, options))
             {
-                var dt = o.Period.StartTime;
+                var dt = o.Start;
                 if (string.Equals(Trigger.Related, TriggerRelation.End, TriggerRelation.Comparison))
                 {
-                    if (o.Period.EndTime != null)
-                    {
-                        dt = o.Period.EndTime;
-                        if (duration == null)
-                        {
-                            duration = o.Period.EffectiveDuration;
-                        }
-                    }
-                    // Use the "last-found" duration as a reference point
-                    else if (duration != null)
-                    {
-                        dt = o.Period.StartTime.Add(duration.Value);
-                    }
-                    else
-                    {
-                        throw new ArgumentException(
-                            "Alarm trigger is relative to the START of the occurrence; however, the occurence has no discernible end.");
-                    }
+                    dt = o.End;
                 }
 
-                occurrences.Add(new AlarmOccurrence(this, dt.Add(Trigger.Duration!.Value), rc));
+                var triggerStart = dt.LocalDateTime
+                    .Plus(triggerDuration)
+                    .InZoneLeniently(dt.Zone);
+
+                occurrences.Add(new AlarmOccurrence(this, triggerStart, rc));
             }
         }
         else
         {
-            var dt = Trigger?.DateTime?.Copy();
+            var dt = Trigger?.DateTime?.ToZonedDateTime();
             if (dt != null)
             {
-                occurrences.Add(new AlarmOccurrence(this, dt, rc));
+                occurrences.Add(new AlarmOccurrence(this, dt.Value, rc));
             }
         }
 
@@ -146,7 +134,7 @@ public virtual IList<AlarmOccurrence> GetOccurrences(IRecurringComponent rc, Cal
     /// <param name="start">The earliest date/time to poll triggered alarms for.</param>
     /// <param name="options"></param>
     /// <returns>A list of <see cref="AlarmOccurrence"/> objects, each containing a triggered alarm.</returns>
-    public virtual IList<AlarmOccurrence> Poll(CalDateTime? start, EvaluationOptions? options = null)
+    public virtual IList<AlarmOccurrence> Poll(DateTimeZone timeZone, Instant? start, EvaluationOptions? options = null)
     {
         var results = new List<AlarmOccurrence>();
 
@@ -156,7 +144,7 @@ public virtual IList<AlarmOccurrence> Poll(CalDateTime? start, EvaluationOptions
             return results;
         }
 
-        results.AddRange(GetOccurrences(rc, start, options));
+        results.AddRange(GetOccurrences(rc, timeZone, start, options));
         return results;
     }
 
@@ -171,22 +159,24 @@ private void AddRepeatedItems(List<AlarmOccurrence> occurrences)
         for (var i = 0; i < len; i++)
         {
             var ao = occurrences[i];
-            if (ao.DateTime == null || ao.Component == null)
+            if (ao.Component == null)
             {
                 continue;
             }
 
-            var alarmTime = ao.DateTime.Copy();
+            var alarmTime = ao.Start;
+            var duration = Duration?.ToPeriod();
 
             for (var j = 0; j < Repeat; j++)
             {
-                if (Duration != null)
-                    alarmTime = alarmTime?.Add(Duration.Value);
-
-                if (alarmTime != null)
+                if (duration != null)
                 {
-                    occurrences.Add(new AlarmOccurrence(this, alarmTime.Copy(), ao.Component));
+                    alarmTime = alarmTime.LocalDateTime
+                        .Plus(duration)
+                        .InZoneLeniently(alarmTime.Zone);
                 }
+
+                occurrences.Add(new AlarmOccurrence(this, alarmTime, ao.Component));
             }
         }
     }
diff --git a/Ical.Net/CalendarComponents/CalendarEvent.cs b/Ical.Net/CalendarComponents/CalendarEvent.cs
index 99f48589a..03fba4ed7 100644
--- a/Ical.Net/CalendarComponents/CalendarEvent.cs
+++ b/Ical.Net/CalendarComponents/CalendarEvent.cs
@@ -25,7 +25,7 @@ namespace Ical.Net.CalendarComponents;
 /// - Related property
 /// - TextCollection DataType for 'text' items separated by commas
 /// </remarks>
-public class CalendarEvent : RecurringComponent, IAlarmContainer, IComparable<CalendarEvent>
+public class CalendarEvent : RecurringComponent, IAlarmContainer
 {
     internal const string ComponentName = "VEVENT";
 
@@ -90,77 +90,6 @@ public virtual Duration? Duration
         }
     }
 
-    /// <summary>
-    /// Gets the duration that gets added to the period start time to get the period end time.
-    /// <para/>
-    /// If the <see cref="CalendarEvent.Duration"/> property is not null, its value will be returned.<br/>
-    /// If <see cref="RecurringComponent.DtStart"/> and <see cref="CalendarEvent.DtEnd"/> are set, it will return <see cref="CalendarEvent.DtEnd"/> minus <see cref="CalendarEvent.DtStart"/>.<br/>
-    /// Otherwise, if DtStart is date-only, it will return a duration of 1d, otherwise it will return <see cref="Duration.Zero"/>.
-    /// </summary>
-    /// <remarks>
-    /// Note: For recurring events, the <b>exact duration</b> of individual occurrences may vary due to DST transitions
-    /// of the given <see cref="RecurringComponent.DtStart"/> and <see cref="CalendarEvent.DtEnd"/> timezones.
-    /// </remarks>
-    /// <returns>The duration that gets added to the period start time to get the period end time.</returns>
-    public Duration EffectiveDuration
-    {
-        get
-        {
-            // 3.8.5.3. Recurrence Rule
-            // If the duration of the recurring component is specified with the
-            // "DURATION" property, then the same NOMINAL duration will apply to
-            // all the members of the generated recurrence set and the exact
-            // duration of each recurrence instance will depend on its specific
-            // start time.
-            if (Duration is not null)
-                return Duration.Value;
-
-            if (DtStart is not { } dtStart)
-            {
-                // Mustn't happen
-                throw new InvalidOperationException("DtStart must be set.");
-            }
-
-            if (DtEnd is { } dtEnd)
-            {
-                /*
-                    The 'DTEND' property for a 'VEVENT' calendar component specifies the
-                    non-inclusive end of the event.
-
-                    3.8.5.3. Recurrence Rule:
-                    If the duration of the recurring component is specified with the
-                    "DTEND" or "DUE" property, then the same EXACT duration will apply
-                    to all the members of the generated recurrence set.
-
-                    We use the difference from DtStart to DtEnd (neglecting timezone),
-                    because the caller will set the period end time to the
-                    same timezone as the event end time. This finally leads to an exact duration
-                    calculation from the zoned start time to the zoned end time.
-                    */
-                return dtEnd.Subtract(dtStart);
-            }
-
-            if (!dtStart.HasTime)
-            {
-                // RFC 5545 3.6.1:
-                // For cases where a "VEVENT" calendar component
-                // specifies a "DTSTART" property with a DATE value type but no
-                // "DTEND" nor "DURATION" property, the event’s duration is taken to
-                // be one day.
-                return DataTypes.Duration.FromDays(1);
-            }
-
-            // For DtStart.HasTime but no DtEnd - also the default case
-            //
-            // RFC 5545 3.6.1:
-            // For cases where a "VEVENT" calendar component
-            // specifies a "DTSTART" property with a DATE-TIME value type but no
-            // "DTEND" property, the event ends on the same calendar date and
-            // time of day specified by the "DTSTART" property.
-            return DataTypes.Duration.Zero;
-        }
-    }
-
     /// <summary>
     /// An alias to the DtEnd field (i.e. end date/time).
     /// </summary>
@@ -306,7 +235,4 @@ protected bool Equals(CalendarEvent? other)
 
         return true;
     }
-
-    /// <inheritdoc/>
-    public int CompareTo(CalendarEvent? other) => DtStart?.CompareTo(other?.DtStart) ?? -1;
 }
diff --git a/Ical.Net/CalendarComponents/FreeBusy.cs b/Ical.Net/CalendarComponents/FreeBusy.cs
index d3d86fc84..46c722e96 100644
--- a/Ical.Net/CalendarComponents/FreeBusy.cs
+++ b/Ical.Net/CalendarComponents/FreeBusy.cs
@@ -5,24 +5,26 @@
 
 using System;
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.Linq;
 using Ical.Net.DataTypes;
 using Ical.Net.Evaluation;
 using Ical.Net.Utility;
+using NodaTime;
 
 namespace Ical.Net.CalendarComponents;
 
 public class FreeBusy : UniqueComponent, IMergeable
 {
-    public static FreeBusy? Create(ICalendarObject obj, FreeBusy freeBusyRequest, EvaluationOptions? options = null)
+    public static FreeBusy? Create(ICalendarObject obj, DateTimeZone timeZone, FreeBusy freeBusyRequest, EvaluationOptions? options = null)
     {
         if ((obj is not IGetOccurrencesTyped occ))
         {
             return null;
         }
 
-        var occurrences = occ.GetOccurrences<CalendarEvent>(freeBusyRequest.Start, options)
-            .TakeWhile(p => (freeBusyRequest.End == null) || (p.Period.StartTime < freeBusyRequest.End));
+        var occurrences = occ.GetOccurrences<CalendarEvent>(timeZone, freeBusyRequest.Start?.ToZonedDateTime(timeZone).ToInstant(), options)
+            .TakeWhile(p => (freeBusyRequest.End == null) || (p.Start.ToInstant() < freeBusyRequest.End.ToInstant()));
 
         var contacts = new List<string>();
         var isFilteredByAttendees = false;
@@ -89,7 +91,11 @@ public class FreeBusy : UniqueComponent, IMergeable
             if (accepted)
             {
                 // If the entry was accepted, add it to our list!
-                fb.Entries.Add(new FreeBusyEntry(o.Period, type));
+
+                // Values MUST always be in UTC on FREEBUSY
+                var period = new DataTypes.Period(o.Start.ToInstant(), o.End.ToInstant());
+
+                fb.Entries.Add(new FreeBusyEntry(period, type));
             }
         }
 
@@ -156,7 +162,12 @@ public virtual CalDateTime? End
         set => Properties.Set("DTEND", value);
     }
 
-    public virtual FreeBusyStatus GetFreeBusyStatus(Period? period)
+    /// <summary>
+    /// All DATE-TIME values must be in the UTC time zone.
+    /// </summary>
+    /// <param name="period"></param>
+    /// <returns></returns>
+    public virtual FreeBusyStatus GetFreeBusyStatus(DataTypes.Period? period)
     {
         var status = FreeBusyStatus.Free;
         if (period == null)
@@ -164,6 +175,16 @@ public virtual FreeBusyStatus GetFreeBusyStatus(Period? period)
             return status;
         }
 
+        if (period.StartTime.IsFloating)
+        {
+            throw new ArgumentException("Period start time must be in UTC");
+        }
+
+        if (period.EndTime is { } endTime && endTime.IsFloating)
+        {
+            throw new ArgumentException("Period end time must be in UTC");
+        }
+
         foreach (var fbe in Entries.Where(fbe => fbe.CollidesWith(period) && status < fbe.Status))
         {
             status = fbe.Status;
@@ -171,7 +192,17 @@ public virtual FreeBusyStatus GetFreeBusyStatus(Period? period)
         return status;
     }
 
+    /// <summary>
+    /// Value must be in the UTC time zone.
+    /// </summary>
+    /// <param name="dt"></param>
+    /// <returns></returns>
     public virtual FreeBusyStatus GetFreeBusyStatus(CalDateTime? dt)
+    {
+        return GetFreeBusyStatus(dt?.ToInstant());
+    }
+
+    public virtual FreeBusyStatus GetFreeBusyStatus(Instant? dt)
     {
         var status = FreeBusyStatus.Free;
         if (dt == null)
@@ -179,7 +210,10 @@ public virtual FreeBusyStatus GetFreeBusyStatus(CalDateTime? dt)
             return status;
         }
 
-        foreach (var fbe in Entries.Where(fbe => fbe.Contains(dt) && status < fbe.Status))
+        // FREEBUSY entries MUST always be UTC time, so compare as instant
+        var matches = Entries.Where(fbe => status < fbe.Status && fbe.Contains(dt.Value));
+
+        foreach (var fbe in matches)
         {
             status = fbe.Status;
         }
diff --git a/Ical.Net/CalendarComponents/IAlarmContainer.cs b/Ical.Net/CalendarComponents/IAlarmContainer.cs
index 9057b996e..3a459e052 100644
--- a/Ical.Net/CalendarComponents/IAlarmContainer.cs
+++ b/Ical.Net/CalendarComponents/IAlarmContainer.cs
@@ -5,6 +5,7 @@
 
 using System.Collections.Generic;
 using Ical.Net.DataTypes;
+using NodaTime;
 
 namespace Ical.Net.CalendarComponents;
 
@@ -24,5 +25,5 @@ public interface IAlarmContainer
     /// <param name="startTime">The earliest allowable alarm occurrence to poll, or <c>null</c>.</param>
     /// <param name="endTime"></param>
     /// <returns>A List of <see cref="AlarmOccurrence"/> objects, one for each occurrence of the <see cref="Alarm"/>.</returns>
-    IList<AlarmOccurrence> PollAlarms(CalDateTime? startTime, CalDateTime? endTime);
+    IList<AlarmOccurrence> PollAlarms(DateTimeZone timeZone, Instant? startTime, Instant? endTime);
 }
diff --git a/Ical.Net/CalendarComponents/RecurringComponent.cs b/Ical.Net/CalendarComponents/RecurringComponent.cs
index 982a423a9..ce61d7be8 100644
--- a/Ical.Net/CalendarComponents/RecurringComponent.cs
+++ b/Ical.Net/CalendarComponents/RecurringComponent.cs
@@ -10,6 +10,7 @@
 using Ical.Net.DataTypes;
 using Ical.Net.Evaluation;
 using Ical.Net.Proxies;
+using NodaTime;
 
 namespace Ical.Net.CalendarComponents;
 
@@ -207,11 +208,16 @@ protected override void OnDeserializing(StreamingContext context)
         Initialize();
     }
 
-    public virtual IEnumerable<Occurrence> GetOccurrences(CalDateTime? startTime = null, EvaluationOptions? options = null)
-        => RecurrenceUtil.GetOccurrences(this, startTime, options);
+    public virtual IEnumerable<Occurrence> GetOccurrences(ZonedDateTime startTime, EvaluationOptions? options = null)
+        => RecurrenceUtil.GetOccurrences(this, startTime.Zone, startTime.ToInstant(), options);
 
-    public virtual IList<AlarmOccurrence> PollAlarms() => PollAlarms(null, null);
+    public virtual IEnumerable<Occurrence> GetOccurrences(DateTimeZone timeZone, Instant? startTime = null, EvaluationOptions? options = null)
+    {
+        return RecurrenceUtil.GetOccurrences(this, timeZone, startTime, options);
+    }
+
+    public virtual IList<AlarmOccurrence> PollAlarms(DateTimeZone timeZone) => PollAlarms(timeZone, null, null);
 
-    public virtual IList<AlarmOccurrence> PollAlarms(CalDateTime? startTime, CalDateTime? endTime)
-        => Alarms.SelectMany(a => a.Poll(startTime).TakeWhile(p => (endTime == null) || (p.Period?.StartTime < endTime))).ToList();
+    public virtual IList<AlarmOccurrence> PollAlarms(DateTimeZone timeZone, Instant? startTime, Instant? endTime)
+        => Alarms.SelectMany(a => a.Poll(timeZone, startTime).TakeWhile(p => (endTime == null) || (p.Start.ToInstant() < endTime))).ToList();
 }
diff --git a/Ical.Net/CalendarComponents/Todo.cs b/Ical.Net/CalendarComponents/Todo.cs
index 16b8c3a4b..debc0d751 100644
--- a/Ical.Net/CalendarComponents/Todo.cs
+++ b/Ical.Net/CalendarComponents/Todo.cs
@@ -10,6 +10,7 @@
 using System.Runtime.Serialization;
 using Ical.Net.DataTypes;
 using Ical.Net.Evaluation;
+using NodaTime;
 
 namespace Ical.Net.CalendarComponents;
 
@@ -55,65 +56,15 @@ public virtual CalDateTime? Due
     //
     // Therefore, Duration is not serialized, as Due
     // should always be extrapolated from the duration.
-    public virtual Duration? Duration
+    public virtual DataTypes.Duration? Duration
     {
-        get => Properties.Get<Duration?>("DURATION");
+        get => Properties.Get<DataTypes.Duration?>("DURATION");
         set
         {
             Properties.Set("DURATION", value);
         }
     }
 
-    /// <summary>
-    /// Gets the duration that gets added to the period start time to get the period end time.
-    /// <para/>
-    /// If the <see cref="Duration"/> property is not null, its value will be returned.<br/>
-    /// If <see cref="RecurringComponent.DtStart"/> and <see cref="Due"/> are set, it will return <see cref="Due"/> minus <see cref="RecurringComponent.DtStart"/>.<br/>
-    /// </summary>
-    /// <remarks>
-    /// Note: For recurring events, the <b>exact duration</b> of individual occurrences may vary due to DST transitions
-    /// of the given <see cref="RecurringComponent.DtStart"/> and <see cref="Due"/> timezones.
-    /// </remarks>
-    /// <returns>The duration that gets added to the period start time to get the period end time.</returns>
-    public Duration? EffectiveDuration
-    {
-        get
-        {
-            // 3.8.5.3. Recurrence Rule
-            // If the duration of the recurring component is specified with the
-            // "DURATION" property, then the same NOMINAL duration will apply to
-            // all the members of the generated recurrence set and the exact
-            // duration of each recurrence instance will depend on its specific
-            // start time.
-            if (Duration is not null)
-                return Duration.Value;
-
-            if (DtStart is not { } dtStart)
-            {
-                // Mustn't happen
-                throw new InvalidOperationException("DtStart must be set.");
-            }
-
-            if (Due is { } dtEnd)
-            {
-                /*
-                    3.8.5.3. Recurrence Rule:
-                    If the duration of the recurring component is specified with the
-                    "DTEND" or "DUE" property, then the same EXACT duration will apply
-                    to all the members of the generated recurrence set.
-
-                    We use the difference from DtStart to DtEnd (neglecting timezone),
-                    because the caller will set the period end time to the
-                    same timezone as the event end time. This finally leads to an exact duration
-                    calculation from the zoned start time to the zoned end time.
-                    */
-                return dtEnd.Subtract(dtStart);
-            }
-
-            return null;
-        }
-    }
-
     public virtual GeographicLocation? GeographicLocation
     {
         get => Properties.Get<GeographicLocation>("GEO");
@@ -184,19 +135,26 @@ public Todo()
     /// </note>
     /// </summary>
     /// <returns>True if the item has been completed</returns>
-    public virtual bool IsCompleted(CalDateTime currDt)
+    public virtual bool IsCompleted(ZonedDateTime currDt)
     {
         if (Status == TodoStatus.Completed)
         {
-            if (Completed == null || Completed.GreaterThan(currDt))
+            if (Completed == null)
+            {
+                return true;
+            }
+
+            var completed = Completed.ToZonedDateTime(currDt.Zone);
+
+            if (completed.ToInstant() > currDt.ToInstant())
             {
                 return true;
             }
 
             // Evaluate to the previous occurrence.
-            var periods = _mEvaluator.EvaluateToPreviousOccurrence(Completed, currDt, options: null);
+            var periods = _mEvaluator.EvaluateToPreviousOccurrence(completed, currDt, options: null);
 
-            return periods.All(p => !p.StartTime.GreaterThan(Completed) || !currDt.GreaterThanOrEqual(p.StartTime));
+            return periods.All(p => p.Start.ToInstant() <= completed.ToInstant() || currDt.ToInstant() < p.Start.ToInstant());
         }
         return false;
     }
@@ -207,9 +165,9 @@ public virtual bool IsCompleted(CalDateTime currDt)
     /// </summary>
     /// <param name="currDt">The date and time to test.</param>
     /// <returns>True if the item is Active as of <paramref name="currDt"/>, False otherwise.</returns>
-    public virtual bool IsActive(CalDateTime currDt)
-        => (DtStart == null || currDt.GreaterThanOrEqual(DtStart))
-           && (!IsCompleted(currDt) && !IsCancelled);
+    public virtual bool IsActive(ZonedDateTime value)
+        => (DtStart == null || value.ToInstant() >= DtStart.ToZonedDateTime(value.Zone).ToInstant())
+           && (!IsCompleted(value) && !IsCancelled);
 
     /// <summary>
     /// Returns True if the item was cancelled.
diff --git a/Ical.Net/CalendarExtensions.cs b/Ical.Net/CalendarExtensions.cs
deleted file mode 100644
index 1da2c3ae1..000000000
--- a/Ical.Net/CalendarExtensions.cs
+++ /dev/null
@@ -1,73 +0,0 @@
-//
-// Copyright ical.net project maintainers and contributors.
-// Licensed under the MIT license.
-//
-
-using System;
-using System.Globalization;
-using Ical.Net.DataTypes;
-
-namespace Ical.Net;
-
-public static class CalendarExtensions
-{
-    /// <summary>
-    /// Calculate the week number according to ISO.8601, as required by RFC 5545.
-    /// </summary>
-    public static int GetIso8601WeekOfYear(this System.Globalization.Calendar calendar, CalDateTime time, DayOfWeek firstDayOfWeek)
-    {
-        // A week is defined as a
-        // seven day period, starting on the day of the week defined to be
-        // the week start(see WKST). Week number one of the calendar year
-        // is the first week that contains at least four (4) days in that
-        // calendar year.
-
-        // We add 3 to make sure the test date is in the 'right' year, because
-        // otherwise we might end up with week 53 in a year that only has 52.
-        var tTest = GetStartOfWeek(time, firstDayOfWeek).AddDays(3);
-        var res = calendar.GetWeekOfYear(tTest.Value, CalendarWeekRule.FirstFourDayWeek, firstDayOfWeek);
-
-        return res;
-    }
-
-    /// <summary>
-    /// Calculate and return the date that represents the first day of the week the given date is
-    /// in, according to the week numbering required by RFC 5545.
-    /// </summary>
-    private static CalDateTime GetStartOfWeek(this CalDateTime t, DayOfWeek firstDayOfWeek)
-    {
-        var t0 = ((int) firstDayOfWeek) % 7;
-        var tn = ((int) t.DayOfWeek) % 7;
-        return t.AddDays(-((tn + 7 - t0) % 7));
-    }
-
-    /// <summary>
-    /// Calculate the year, the given date's week belongs to according to ISO 8601, as required by RFC 5545.
-    /// </summary>
-    /// <remarks>
-    /// A date's nominal year may be different from the year, the week belongs to that the date is in.
-    /// I.e. the first and last week of the year may belong to a different year than the date's year.
-    /// E.g. for `2019-12-31` with first day of the week being Monday, the method will return 2020,
-    /// because the week that contains `2019-12-31` is the first week of 2020.
-    /// </remarks>
-    public static int GetIso8601YearOfWeek(this System.Globalization.Calendar calendar, CalDateTime time, DayOfWeek firstDayOfWeek)
-    {
-        var year = time.Year;
-        if ((time.Month >= 12) && (calendar.GetIso8601WeekOfYear(time, firstDayOfWeek) == 1))
-            year++;
-        else if ((time.Month == 1) && (calendar.GetIso8601WeekOfYear(time, firstDayOfWeek) >= 52))
-            year--;
-
-        return year;
-    }
-
-    /// <summary>
-    /// Calculate the number of weeks in the given year according to ISO 8601, as required by RFC 5545.
-    /// </summary>
-    public static int GetIso8601WeeksInYear(this System.Globalization.Calendar calendar, int year, DayOfWeek firstDayOfWeek)
-    {
-        // The last week of the year is the week that contains the 4th-last day of the year (which is the 28th of December in Gregorian Calendar).
-        var testTime = new CalDateTime(year + 1, 1, 1, 0, 0, 0, null).AddDays(-4);
-        return calendar.GetIso8601WeekOfYear(testTime, firstDayOfWeek);
-    }
-}
diff --git a/Ical.Net/CollectionExtensions.cs b/Ical.Net/CollectionExtensions.cs
index e2851c489..e96c10d88 100644
--- a/Ical.Net/CollectionExtensions.cs
+++ b/Ical.Net/CollectionExtensions.cs
@@ -9,6 +9,7 @@
 using Ical.Net.CalendarComponents;
 using Ical.Net.DataTypes;
 using Ical.Net.Evaluation;
+using NodaTime;
 
 namespace Ical.Net;
 
@@ -30,8 +31,13 @@ public static class CollectionExtensions
     /// <returns>
     /// The elements of the sequence of occurrences to only include those that start before the specified period end.
     /// </returns>
+    ///
+    [Obsolete("Use NodaTime.Instant to specify period end.")]
     public static IEnumerable<Occurrence> TakeWhileBefore(this IEnumerable<Occurrence> sequence, CalDateTime periodEnd)
-        => sequence.TakeWhile(p => p.Period.StartTime < periodEnd);
+        => sequence.TakeWhile(p => p.Start.ToInstant() < periodEnd.ToInstant());
+
+    public static IEnumerable<Occurrence> TakeWhileBefore(this IEnumerable<Occurrence> sequence, Instant periodEnd)
+        => sequence.TakeWhile(p => p.Start.ToInstant() < periodEnd);
 
     /// <summary>
     /// Returns the elements of the sequence of periods to only include those that start before the specified period end.
@@ -53,6 +59,6 @@ public static IEnumerable<Occurrence> TakeWhileBefore(this IEnumerable<Occurrenc
     /// <returns>
     /// The elements of the sequence of periods to only include those that start before the specified period end.
     /// </returns>
-    public static IEnumerable<Period> TakeWhileBefore(this IEnumerable<Period> sequence, CalDateTime periodEnd)
-        => sequence.TakeWhile(p => p.StartTime < periodEnd);
+    public static IEnumerable<EvaluationPeriod> TakeWhileBefore(this IEnumerable<EvaluationPeriod> sequence, Instant periodEnd)
+        => sequence.TakeWhile(p => p.Start.ToInstant() < periodEnd);
 }
diff --git a/Ical.Net/DataTypes/AlarmOccurrence.cs b/Ical.Net/DataTypes/AlarmOccurrence.cs
index 530e6e517..304cffe31 100644
--- a/Ical.Net/DataTypes/AlarmOccurrence.cs
+++ b/Ical.Net/DataTypes/AlarmOccurrence.cs
@@ -3,8 +3,8 @@
 // Licensed under the MIT license.
 //
 
-using System;
 using Ical.Net.CalendarComponents;
+using NodaTime;
 
 namespace Ical.Net.DataTypes;
 
@@ -18,29 +18,23 @@ namespace Ical.Net.DataTypes;
 /// </remarks>
 public class AlarmOccurrence
 {
-    public Period? Period { get; set; }
+    public ZonedDateTime Start { get; private set; }
 
-    public IRecurringComponent? Component { get; set; }
+    public IRecurringComponent? Component { get; private set; }
 
-    public Alarm? Alarm { get; set; }
-
-    public CalDateTime? DateTime
-    {
-        get => Period?.StartTime;
-        set => Period = value != null ? new Period(value) : null;
-    }
+    public Alarm? Alarm { get; private set; }
 
     public AlarmOccurrence(AlarmOccurrence ao)
     {
-        Period = ao.Period;
+        Start = ao.Start;
         Component = ao.Component;
         Alarm = ao.Alarm;
     }
 
-    public AlarmOccurrence(Alarm a, CalDateTime dt, IRecurringComponent rc)
+    public AlarmOccurrence(Alarm a, ZonedDateTime start, IRecurringComponent rc)
     {
         Alarm = a;
-        Period = new Period(dt);
+        Start = start;
         Component = rc;
     }
 }
diff --git a/Ical.Net/DataTypes/CalDateTime.cs b/Ical.Net/DataTypes/CalDateTime.cs
index bd1ece977..5780ba425 100644
--- a/Ical.Net/DataTypes/CalDateTime.cs
+++ b/Ical.Net/DataTypes/CalDateTime.cs
@@ -3,13 +3,15 @@
 // Licensed under the MIT license.
 //
 
-using Ical.Net.Serialization.DataTypes;
-using Ical.Net.Utility;
-using NodaTime;
 using System;
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.IO;
+using Ical.Net.Serialization.DataTypes;
+using Ical.Net.Utility;
+using NodaTime;
+using NodaTime.Extensions;
+using NodaTime.Text;
 
 namespace Ical.Net.DataTypes;
 
@@ -23,12 +25,15 @@ namespace Ical.Net.DataTypes;
 /// This is because RFC 5545, Section 3.3.5, does not allow for fractional seconds.
 /// </remarks>
 /// </summary>
-public sealed class CalDateTime : IComparable<CalDateTime>, IFormattable
+public sealed class CalDateTime : IFormattable, IEquatable<CalDateTime>
 {
     // The date part that is used to return the Value property.
-    private DateOnly _dateOnly;
+    private readonly LocalDate _localDate;
     // The time part that is used to return the Value property.
-    private TimeOnly? _timeOnly;
+    private readonly LocalTime? _localTime;
+
+    private readonly string? _tzId;
+
 
     /// <summary>
     /// The timezone ID for Universal Coordinated Time (UTC).
@@ -62,20 +67,6 @@ private CalDateTime()
         // required for the SerializerFactory to work
     }
 
-    /// <summary>
-    /// Creates a new instance of the <see cref="CalDateTime"/> class.
-    /// The instance will represent an RFC 5545, Section 3.3.5, DATE-TIME value, if <see cref="CalDateTime.HasTime"/> is <see langword="true"/>.
-    /// It will represent an RFC 5545, Section 3.3.4, DATE value, if <see cref="CalDateTime.HasTime"/> is <see langword="false"/>.
-    /// </summary>
-    /// <param name="value"></param>
-    public CalDateTime(CalDateTime value)
-    {
-        if (value.HasTime)
-            Initialize(DateOnly.FromDateTime(value.Value), TimeOnly.FromDateTime(value.Value), value.TzId);
-        else
-            Initialize(DateOnly.FromDateTime(value.Value), null, value.TzId);
-    }
-
     /// <summary>
     /// Creates a new instance of the <see cref="CalDateTime"/> class.
     /// The instance will represent an RFC 5545, Section 3.3.5, DATE-TIME value, if <see paramref="hasTime"/> is <see langword="true"/>.
@@ -118,13 +109,11 @@ public CalDateTime(DateTime value, bool hasTime = true) : this(
     /// The instance will represent an RFC 5545, Section 3.3.5, DATE-TIME value, if <see paramref="hasTime"/> is <see langword="true"/>.
     /// It will represent an RFC 5545, Section 3.3.4, DATE value, if <see paramref="hasTime"/> is <see langword="false"/>.
     /// </param>
-    public CalDateTime(DateTime value, string? tzId, bool hasTime = true)
-    {
-        if (hasTime)
-            Initialize(DateOnly.FromDateTime(value), TimeOnly.FromDateTime(value), tzId);
-        else
-            Initialize(DateOnly.FromDateTime(value), null, tzId);
-    }
+    public CalDateTime(DateTime value, string? tzId, bool hasTime = true) : this(
+        LocalDate.FromDateTime(value),
+        hasTime ? LocalDateTime.FromDateTime(value).TimeOfDay : null,
+        tzId)
+    { }
 
     /// <summary>
     /// Creates a new instance of the <see cref="CalDateTime"/> class using the specified timezone.
@@ -141,9 +130,8 @@ public CalDateTime(DateTime value, string? tzId, bool hasTime = true)
     /// <param name="minute"></param>
     /// <param name="second"></param>
     public CalDateTime(int year, int month, int day, int hour, int minute, int second, string? tzId = null) //NOSONAR - must keep this signature
-    {
-        Initialize(new DateOnly(year, month, day), new TimeOnly(hour, minute, second), tzId);
-    }
+        : this(new LocalDate(year, month, day), new LocalTime(hour, minute, second), tzId)
+    { }
 
     /// <summary>
     /// Creates a new instance of the <see cref="CalDateTime"/> class with <see cref="TzId"/> set to <see langword="null"/>.
@@ -154,20 +142,29 @@ public CalDateTime(int year, int month, int day, int hour, int minute, int secon
     /// <param name="month"></param>
     /// <param name="day"></param>
     public CalDateTime(int year, int month, int day)
-    {
-        Initialize(new DateOnly(year, month, day), null, null);
-    }
+        : this(new LocalDate(year, month, day), null, null)
+    { }
+
+    public CalDateTime(LocalDate value, string? tzId = null)
+        : this(value, null, tzId)
+    { }
+
+    public CalDateTime(LocalDateTime value, string? tzId = null)
+        : this(value.Date, value.TimeOfDay, tzId)
+    { }
 
     /// <summary>
-    /// Creates a new instance of the <see cref="CalDateTime"/> class with <see cref="TzId"/> set to <see langword="null"/>.
-    /// The instance will represent an RFC 5545, Section 3.3.4, DATE value,
-    /// and thus it cannot have a timezone.
+    /// Note that this drops the time zone offset,
+    /// so the value is not always exactly the same
+    /// when converting back to ZonedDateTime.
     /// </summary>
-    /// <param name="date"></param>
-    public CalDateTime(DateOnly date)
-    {
-        Initialize(date, null, null);
-    }
+    /// <param name="value"></param>
+    internal CalDateTime(ZonedDateTime value)
+        : this(value.LocalDateTime, value.Zone.Id)
+    { }
+
+    public CalDateTime(Instant instant) : this(instant.InUtc())
+    { }
 
     /// <summary>
     /// Creates a new instance of the <see cref="CalDateTime"/> class using the specified timezone.
@@ -179,9 +176,23 @@ public CalDateTime(DateOnly date)
     /// </param>
     /// <param name="date"></param>
     /// <param name="time"></param>
-    public CalDateTime(DateOnly date, TimeOnly? time, string? tzId = null)
+    public CalDateTime(LocalDate date, LocalTime? time, string? tzId = null)
     {
-        Initialize(date, time, tzId);
+        // NodaTime supports year values <1 (BCE). Make sure these
+        // years are considered invalid.
+        if (date.Year < 1)
+        {
+            throw new ArgumentOutOfRangeException(nameof(date), "Year must be a positive value");
+        }
+
+        _localDate = date;
+        _localTime = TruncateTimeToSeconds(time);
+
+        _tzId = tzId switch
+        {
+            _ when !time.HasValue => null,
+            _ => tzId // can also be UtcTzId
+        };
     }
 
     /// <summary>
@@ -205,7 +216,9 @@ public CalDateTime(string value, string? tzId = null)
         var dt = serializer.Deserialize(new StringReader(value)) as CalDateTime
                  ?? throw new InvalidOperationException($"Failure when deserializing value '{value}'");
 
-        Initialize(dt._dateOnly, dt._timeOnly, dt.IsUtc ? UtcTzId : tzId);
+        _localDate = dt._localDate;
+        _localTime = dt._localTime;
+        _tzId = dt.IsUtc ? UtcTzId : tzId;
 
         if (dt.IsUtc && tzId != null && !string.Equals(tzId, UtcTzId, StringComparison.OrdinalIgnoreCase))
         {
@@ -215,17 +228,12 @@ public CalDateTime(string value, string? tzId = null)
         }
     }
 
-    private void Initialize(DateOnly dateOnly, TimeOnly? timeOnly, string? tzId)
-    {
-        _dateOnly = dateOnly;
-        _timeOnly = TruncateTimeToSeconds(timeOnly);
+#if NET6_0_OR_GREATER
+    public CalDateTime(DateOnly date) : this(date, null, null) { }
 
-        _tzId = tzId switch
-        {
-            _ when !timeOnly.HasValue => null,
-            _ => tzId // can also be UtcTzId
-        };
-    }
+    public CalDateTime(DateOnly date, TimeOnly? time, string? tzId = null)
+        : this(date.ToLocalDate(), time?.ToLocalTime(), tzId) { }
+#endif
 
     public bool Equals(CalDateTime? other) => this == other;
 
@@ -234,44 +242,7 @@ public override bool Equals(object? obj)
         => obj is CalDateTime other && this == other;
 
     /// <inheritdoc/>
-    public override int GetHashCode()
-    {
-        unchecked
-        {
-            var hashCode = Value.GetHashCode();
-            hashCode = (hashCode * 397) ^ HasTime.GetHashCode();
-            hashCode = (hashCode * 397) ^ (TzId != null ? TzId.GetHashCode() : 0);
-            return hashCode;
-        }
-    }
-
-    public static bool operator <(CalDateTime? left, CalDateTime? right)
-    {
-        return left != null
-               && right != null
-               && ((left.IsFloating || right.IsFloating || left.TzId == right.TzId) ? left.Value < right.Value : left.AsUtc < right.AsUtc);
-    }
-
-    public static bool operator >(CalDateTime? left, CalDateTime? right)
-    {
-        return left != null
-               && right != null
-               && ((left.IsFloating || right.IsFloating || left.TzId == right.TzId) ? left.Value > right.Value : left.AsUtc > right.AsUtc);
-    }
-
-    public static bool operator <=(CalDateTime? left, CalDateTime? right)
-    {
-        return left != null
-               && right != null
-               && ((left.IsFloating || right.IsFloating || left.TzId == right.TzId) ? left.Value <= right.Value : left.AsUtc <= right.AsUtc);
-    }
-
-    public static bool operator >=(CalDateTime? left, CalDateTime? right)
-    {
-        return left != null
-               && right != null
-               && ((left.IsFloating || right.IsFloating || left.TzId == right.TzId) ? left.Value >= right.Value : left.AsUtc >= right.AsUtc);
-    }
+    public override int GetHashCode() => HashCode.Combine(_localDate, _localTime, _tzId);
 
     public static bool operator ==(CalDateTime? left, CalDateTime? right)
     {
@@ -285,14 +256,9 @@ public override int GetHashCode()
             return false;
         }
 
-        if (left.IsFloating != right.IsFloating)
-        {
-            return false;
-        }
-
-        return left.Value.Equals(right.Value)
-               && left.HasTime == right.HasTime
-               && string.Equals(left.TzId, right.TzId, StringComparison.OrdinalIgnoreCase);
+        return left._localDate == right._localDate
+            && left._localTime == right._localTime
+            && string.Equals(left.TzId, right.TzId, StringComparison.OrdinalIgnoreCase);
     }
 
     public static bool operator !=(CalDateTime? left, CalDateTime? right)
@@ -303,10 +269,11 @@ public override int GetHashCode()
     /// <summary>
     /// Converts the date/time to UTC (Coordinated Universal Time)
     /// If <see cref="IsFloating"/>==<see langword="true"/>
-    /// it means that the <see cref="Value"/> is considered as local time for every timezone:
-    /// The returned <see cref="Value"/> is unchanged, but with <see cref="DateTimeKind.Utc"/>.
+    /// it means that the value is considered as local time for every timezone:
+    /// The returned value is unchanged, but with <see cref="DateTimeKind.Utc"/>.
     /// </summary>
-    public DateTime AsUtc => DateTime.SpecifyKind(ToTimeZone(UtcTzId).Value, DateTimeKind.Utc);
+    ///
+    public DateTime AsUtc => ToInstant().ToDateTimeUtc();
 
     /// <summary>
     /// Gets the date and time value in the ISO calendar as a <see cref="DateTime"/> type with <see cref="DateTimeKind.Unspecified"/>.
@@ -316,23 +283,7 @@ public override int GetHashCode()
     /// Use <see cref="IsUtc"/> along with <see cref="TzId"/> and <see cref="IsFloating"/>
     /// to control how this date/time is handled.
     /// </summary>
-    public DateTime Value
-    {
-        get
-        {
-            if (_timeOnly.HasValue)
-            {
-                return new DateTime(_dateOnly.Year, _dateOnly.Month,
-                    _dateOnly.Day, _timeOnly.Value.Hour, _timeOnly.Value.Minute, _timeOnly.Value.Second,
-                    DateTimeKind.Unspecified);
-            }
-
-            // No time part
-            return new DateTime(_dateOnly.Year, _dateOnly.Month, _dateOnly.Day,
-                0, 0, 0,
-                DateTimeKind.Unspecified);
-        }
-    }
+    public DateTime Value => ToLocalDateTime().ToDateTimeUnspecified();
 
     /// <summary>
     /// Returns <see langword="true"/>, if the date/time value is floating.
@@ -355,9 +306,7 @@ public DateTime Value
     /// <summary>
     /// <see langword="true"/> if the underlying <see cref="DateTime"/> <see cref="Value"/> has a 'time' part (hour, minute, second).
     /// </summary>
-    public bool HasTime => _timeOnly.HasValue;
-
-    private string? _tzId;
+    public bool HasTime => _localTime.HasValue;
 
     /// <summary>
     /// Gets the timezone ID of this <see cref="CalDateTime"/> instance.
@@ -373,67 +322,128 @@ public DateTime Value
     public string? TimeZoneName => TzId;
 
     /// <summary>
-    /// Gets the year that applies to the <see cref="Value"/>.
+    /// Gets the year.
     /// </summary>
-    public int Year => Value.Year;
+    public int Year => _localDate.Year;
 
     /// <summary>
-    /// Gets the month that applies to the <see cref="Value"/>.
+    /// Gets the month.
     /// </summary>
-    public int Month => Value.Month;
+    public int Month => _localDate.Month;
 
     /// <summary>
-    /// Gets the day that applies to the <see cref="Value"/>.
+    /// Gets the day.
     /// </summary>
-    public int Day => Value.Day;
+    public int Day => _localDate.Day;
 
     /// <summary>
-    /// Gets the hour that applies to the <see cref="Value"/>.
+    /// Gets the hour.
     /// </summary>
-    public int Hour => Value.Hour;
+    public int Hour => _localTime?.Hour ?? 0;
 
     /// <summary>
-    /// Gets the minute that applies to the <see cref="Value"/>.
+    /// Gets the minute.
     /// </summary>
-    public int Minute => Value.Minute;
+    public int Minute => _localTime?.Minute ?? 0;
 
     /// <summary>
-    /// Gets the second that applies to the <see cref="Value"/>.
+    /// Gets the second.
     /// </summary>
-    public int Second => Value.Second;
+    public int Second => _localTime?.Second ?? 0;
 
     /// <summary>
-    /// Gets the DayOfWeek that applies to the <see cref="Value"/>.
+    /// Gets the DayOfWeek.
     /// </summary>
-    public DayOfWeek DayOfWeek => Value.DayOfWeek;
+    public DayOfWeek DayOfWeek => _localDate.DayOfWeek.ToDayOfWeek();
 
     /// <summary>
-    /// Gets the DayOfYear that applies to the <see cref="Value"/>.
+    /// Gets the DayOfYear.
     /// </summary>
-    public int DayOfYear => Value.DayOfYear;
+    public int DayOfYear => _localDate.DayOfYear;
 
     /// <summary>
-    /// Gets the date portion of the <see cref="Value"/>.
+    /// Gets the date.
     /// </summary>
-    public DateOnly Date => _dateOnly;
+    public LocalDate Date => _localDate;
 
     /// <summary>
-    /// Gets the time portion of the <see cref="Value"/>, or <see langword="null"/> if the <see cref="Value"/> is a pure date.
+    /// Gets the time, or <see langword="null"/> if there is no time.
     /// </summary>
-    public TimeOnly? Time => _timeOnly;
+    public LocalTime? Time => _localTime;
+
+#if NET6_0_OR_GREATER
+
+    /// <summary>
+    /// Gets the date..
+    /// </summary>
+    public DateOnly ToDateOnly() => _localDate.ToDateOnly();
+
+    /// <summary>
+    /// Gets the time, or <see langword="null"/> if there is no time.
+    /// </summary>
+    public TimeOnly? ToTimeOnly() => _localTime?.ToTimeOnly();
+#endif
 
     /// <summary>
     /// Any <see cref="Time"/> values are truncated to seconds, because
     /// RFC 5545, Section 3.3.5 does not allow for fractional seconds.
     /// </summary>
-    private static TimeOnly? TruncateTimeToSeconds(TimeOnly? time)
+    private static LocalTime? TruncateTimeToSeconds(LocalTime? time)
     {
         if (time is null)
         {
             return null;
         }
 
-        return new TimeOnly(time.Value.Hour, time.Value.Minute, time.Value.Second);
+        return TimeAdjusters.TruncateToSecond(time.Value);
+    }
+
+    public LocalDateTime ToLocalDateTime()
+        => _localDate.At(_localTime ?? LocalTime.Midnight);
+
+    public Instant ToInstant() => ToZonedDateTime().ToInstant();
+
+    public ZonedDateTime ToZonedDateTime()
+    {
+        if (_tzId is null)
+        {
+            return ToLocalDateTime().InUtc();
+        }
+        else
+        {
+            return DateUtil.GetZone(_tzId).AtLeniently(ToLocalDateTime());
+        }
+    }
+
+    public ZonedDateTime ToZonedDateTime(DateTimeZone timeZone)
+    {
+        if (_tzId is null)
+        {
+            return ToLocalDateTime().InZoneLeniently(timeZone);
+        }
+        else
+        {
+            return DateUtil.GetZone(_tzId)
+                .AtLeniently(ToLocalDateTime())
+                .WithZone(timeZone);
+        }
+    }
+
+    public ZonedDateTime ToZonedDateTime(string zoneId)
+    {
+        return ToZonedDateTime(DateUtil.GetZone(zoneId));
+    }
+
+    public ZonedDateTime AsZonedOrDefault(DateTimeZone timeZone)
+    {
+        if (_tzId is null)
+        {
+            return ToLocalDateTime().InZoneLeniently(timeZone);
+        }
+        else
+        {
+            return DateUtil.GetZone(_tzId).AtLeniently(ToLocalDateTime());
+        }
     }
 
     /// <summary>
@@ -447,23 +457,11 @@ public DateTime Value
     public CalDateTime ToTimeZone(string? otherTzId)
     {
         if (otherTzId is null)
-            return new CalDateTime(Value, null, HasTime);
-
-        ZonedDateTime converted;
-        if (IsFloating)
-        {
-            // Make sure, we properly fix the time if it doesn't exist in the target tz.
-            converted = DateUtil.ToZonedDateTimeLeniently(Value, otherTzId);
-        }
-        else
         {
-            var zonedOriginal = DateUtil.ToZonedDateTimeLeniently(Value, TzId!);
-            converted = zonedOriginal.WithZone(DateUtil.GetZone(otherTzId));
+            return new(_localDate, _localTime);
         }
 
-        return converted.Zone == DateTimeZone.Utc
-            ? new CalDateTime(converted.ToDateTimeUtc(), UtcTzId)
-            : new CalDateTime(converted.ToDateTimeUnspecified(), otherTzId);
+        return new(ToZonedDateTime(otherTzId));
     }
 
     /// <summary>
@@ -502,72 +500,44 @@ public CalDateTime Add(Duration d)
         // greatest order time components MUST be added first, that is, the number of days MUST be
         // added first, followed by the number of hours, number of minutes, and number of seconds.
 
-        (TimeSpan? nominalPart, TimeSpan? exactPart) dt;
-        if (TzId is null)
-            dt = (d.ToTimeSpanUnspecified(), null);
+        if (_localTime is null)
+        {
+            // The value is date only and the duration has no time,
+            // so just add to the date.
+            var date = ToLocalDateTime().Date.Plus(d.GetNominalPart());
+            return new(date, _tzId);
+        }
         else
-            dt = (d.HasDate ? d.DateAsTimeSpan : null, d.HasTime ? d.TimeAsTimeSpan : null);
-
-        var newDateTime = this;
-        if (dt.nominalPart is not null)
-            newDateTime = new CalDateTime(newDateTime.Value.Add(dt.nominalPart.Value), TzId, HasTime);
-
-        if (dt.exactPart is not null)
-            newDateTime = new CalDateTime(newDateTime.AsUtc.Add(dt.exactPart.Value), UtcTzId, HasTime);
-        
-        if (TzId is not null)
-            // Convert to the original timezone even if already set to ensure we're not in a non-existing time.
-            newDateTime = newDateTime.ToTimeZone(TzId);
-
-        return newDateTime;
-    }
-
-    /// <summary>Returns a new <see cref="TimeSpan" /> from subtracting the specified <see cref="CalDateTime"/> from to the value of this instance.</summary>
-    /// <param name="dt"></param>
-    public TimeSpan SubtractExact(CalDateTime dt) => AsUtc - dt.AsUtc;
-
-    /// <summary>
-    /// Returns a new <see cref="Duration"/> from subtracting the specified <see cref="CalDateTime"/> from to the value of this instance.
-    /// </summary>
-    /// <param name="dt"></param>
-    /// <returns></returns>
-    /// <exception cref="InvalidOperationException"></exception>
-    public Duration Subtract(CalDateTime dt)
-    {
-        if (this.TzId is not null)
-            return SubtractExact(dt).ToDurationExact();
-
-        if (dt.HasTime != HasTime)
-            throw new InvalidOperationException($"Trying to calculate the difference between dates of different types. An instance of type DATE cannot be subtracted from a DATE-TIME and vice versa: {ToString()} - {dt.ToString()}");
-
-        return (Value - dt.Value).ToDuration();
+        {
+            // Treat floating values as UTC, and add date and time
+            var zoned = ToZonedDateTime();
+            var result = zoned
+                .LocalDateTime
+                .Plus(d.GetNominalPart())
+                .InZoneLeniently(zoned.Zone)
+                .Plus(d.GetTimePart());
+
+            // Use the original time zone (which may be null)
+            return new(result.LocalDateTime, _tzId);
+        }
     }
 
-    internal CalDateTime Copy()
-        => new CalDateTime(_dateOnly, _timeOnly, _tzId);
-
     /// <inheritdoc cref="DateTime.AddYears"/>
     public CalDateTime AddYears(int years)
     {
-        var dt = Copy();
-        dt._dateOnly = dt._dateOnly.AddYears(years);
-        return dt;
+        return new(_localDate.PlusYears(years), _localTime, _tzId);
     }
 
     /// <inheritdoc cref="DateTime.AddMonths"/>
     public CalDateTime AddMonths(int months)
     {
-        var dt = Copy();
-        dt._dateOnly = dt._dateOnly.AddMonths(months);
-        return dt;
+        return new(_localDate.PlusMonths(months), _localTime, _tzId);
     }
 
     /// <inheritdoc cref="DateTime.AddDays"/>
     public CalDateTime AddDays(int days)
     {
-        var dt = Copy();
-        dt._dateOnly = dt._dateOnly.AddDays(days);
-        return dt;
+        return new(_localDate.PlusDays(days), _localTime, _tzId);
     }
 
     /// <inheritdoc cref="DateTime.AddHours"/>
@@ -591,56 +561,6 @@ public CalDateTime AddDays(int days)
     /// </exception>
     public CalDateTime AddSeconds(int seconds) => Add(Duration.FromSeconds(seconds));
 
-    /// <summary>
-    /// Returns <see langword="true"/> if the current <see cref="CalDateTime"/> instance is less than <paramref name="dt"/>.
-    /// </summary>
-    public bool LessThan(CalDateTime? dt) => this < dt;
-
-    /// <summary>
-    /// Returns <see langword="true"/> if the current <see cref="CalDateTime"/> instance is greater than <paramref name="dt"/>.
-    /// </summary>
-    public bool GreaterThan(CalDateTime? dt) => this > dt;
-
-    /// <summary>
-    /// Returns <see langword="true"/> if the current <see cref="CalDateTime"/> instance is less than or equal to <paramref name="dt"/>.
-    /// </summary>
-    public bool LessThanOrEqual(CalDateTime? dt) => this <= dt;
-
-    /// <summary>
-    /// Returns <see langword="true"/> if the current <see cref="CalDateTime"/> instance is greater than or equal to <paramref name="dt"/>.
-    /// </summary>
-    public bool GreaterThanOrEqual(CalDateTime? dt) => this >= dt;
-
-    /// <summary>
-    /// Compares the current instance with another <see cref="CalDateTime"/> object and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other CalDateTime.
-    /// </summary>
-    /// <param name="dt">The <see cref="CalDateTime"/> object to compare with this instance.</param>
-    /// <returns>A value that indicates the relative order of the objects being compared. The return value has these meanings:
-    /// Less than zero: This instance is less than <paramref name="dt"/>.
-    /// Zero: This instance is equal to <paramref name="dt"/>.
-    /// Greater than zero: This instance is greater than <paramref name="dt"/>.
-    /// </returns>
-    public int CompareTo(CalDateTime? dt)
-    {
-        if (dt == null)
-        {
-            return 1;
-        }
-
-        if (Equals(dt))
-        {
-            return 0;
-        }
-
-        if (this < dt)
-        {
-            return -1;
-        }
-
-        // Meaning "this > dt"
-        return 1;
-    }
-
     /// <inheritdoc />
     public override string ToString() => ToString(null, null);
 
@@ -650,18 +570,27 @@ public int CompareTo(CalDateTime? dt)
     /// <inheritdoc cref="ToString()"/>
     public string ToString(string? format, IFormatProvider? formatProvider)
     {
+        // Use the .NET format options to format
         formatProvider ??= CultureInfo.InvariantCulture;
-        var dateTimeOffset = DateUtil.ToZonedDateTimeLeniently(Value, _tzId ?? string.Empty).ToDateTimeOffset();
 
-        // Use the .NET format options to format the DateTimeOffset
+        // Print only the time zone ID, not the time zone offset.
+        // The spec does not allow including a time zone offset to
+        // specify a DATE-TIME value, so this should not include it.
         var tzIdString = _tzId is not null ? $" {_tzId}" : string.Empty;
 
         if (HasTime)
         {
-            return $"{dateTimeOffset.ToString(format, formatProvider)}{tzIdString}";
+            return ToLocalDateTime().ToString(format, formatProvider) + tzIdString;
+        }
+
+        // Handle special case for "O" format that NodaTime.LocalDate
+        // does not support. This is the ISO 8601 date format, so it
+        // always uses the invariant culture.
+        if (format == "O")
+        {
+            return LocalDatePattern.Iso.Format(_localDate) + tzIdString;
         }
 
-        // No time part
-        return $"{DateOnly.FromDateTime(dateTimeOffset.Date).ToString(format ?? "d", formatProvider)}{tzIdString}";
+        return _localDate.ToString(format ?? "d", formatProvider) + tzIdString;
     }
 }
diff --git a/Ical.Net/DataTypes/Duration.cs b/Ical.Net/DataTypes/Duration.cs
index 6fd3dc070..b3b88da8b 100644
--- a/Ical.Net/DataTypes/Duration.cs
+++ b/Ical.Net/DataTypes/Duration.cs
@@ -45,6 +45,43 @@ public Duration(int? weeks = null, int? days = null, int? hours = null, int? min
         Seconds = seconds;
     }
 
+    public NodaTime.Period ToPeriod()
+    {
+        var b = new NodaTime.PeriodBuilder
+        {
+            Weeks = Weeks ?? 0,
+            Days = Days ?? 0,
+            Hours = Hours ?? 0,
+            Minutes = Minutes ?? 0,
+            Seconds = Seconds ?? 0
+        };
+
+        return b.Build();
+    }
+
+    public NodaTime.Period GetNominalPart()
+    {
+        var b = new NodaTime.PeriodBuilder
+        {
+            Weeks = Weeks ?? 0,
+            Days = Days ?? 0,
+        };
+
+        return b.Build();
+    }
+
+    public NodaTime.Duration GetTimePart()
+    {
+        var b = new NodaTime.PeriodBuilder
+        {
+            Hours = Hours ?? 0,
+            Minutes = Minutes ?? 0,
+            Seconds = Seconds ?? 0,
+        };
+
+        return b.Build().ToDuration();
+    }
+
     /// <summary>
     /// Gets the number of weeks.
     /// </summary>
@@ -170,18 +207,6 @@ internal static Duration FromTimeSpan(TimeSpan t)
     public TimeSpan ToTimeSpanUnspecified()
         => new TimeSpan((Weeks ?? 0) * 7 + (Days ?? 0), Hours ?? 0, Minutes ?? 0, Seconds ?? 0);
 
-    /// <summary>
-    /// Convert the instance to a <see cref="TimeSpan"/>, treating the days as nominal duration and
-    /// the time part as exact.
-    /// </summary>
-    /// <remarks>
-    /// A duration's days and weeks are considered nominal durations, while the time fields are considered exact values.
-    /// To convert a duration to a <see cref="TimeSpan"/> while considering the days and weeks as nominal durations,
-    /// use <see cref="ToTimeSpan"/>.
-    /// </remarks>
-    public TimeSpan ToTimeSpan(CalDateTime start)
-        => start.Add(this).SubtractExact(start);
-
     /// <summary>
     /// Gets a value indicating whether the duration is zero, that is, all fields are null or 0.
     /// </summary>
diff --git a/Ical.Net/DataTypes/FreeBusyEntry.cs b/Ical.Net/DataTypes/FreeBusyEntry.cs
index 650967c3b..81a1dd459 100644
--- a/Ical.Net/DataTypes/FreeBusyEntry.cs
+++ b/Ical.Net/DataTypes/FreeBusyEntry.cs
@@ -3,6 +3,9 @@
 // Licensed under the MIT license.
 //
 
+using System;
+using NodaTime;
+
 namespace Ical.Net.DataTypes;
 
 public class FreeBusyEntry : Period
@@ -20,6 +23,11 @@ public FreeBusyEntry(Period period, FreeBusyStatus status)
         // Probably the Period object should just have a FreeBusyStatus directly?
         CopyFrom(period);
         Status = status;
+
+        if (EndTime is null && Duration is null)
+        {
+            throw new ArgumentException("Period must have a Duration or EndTime", nameof(period));
+        }
     }
 
     /// <inheritdoc/>
@@ -32,4 +40,109 @@ public override void CopyFrom(ICopyable obj)
             Status = fb.Status;
         }
     }
+
+    /// <summary>
+    /// For backwards compatibility. Value must be in UTC time.
+    /// </summary>
+    /// <param name="dt"></param>
+    /// <returns></returns>
+    public bool Contains(CalDateTime? dt)
+    {
+        return dt is not null && Contains(dt.ToInstant());
+    }
+
+    /// <summary>
+    /// Checks if the given instant is contained within the period.
+    /// This assumes that all CalDateTime values are in UTC time
+    /// according to the spec.
+    /// </summary>
+    public bool Contains(Instant value)
+    {
+        var startInstant = StartTime.ToInstant();
+        if (startInstant > value)
+        {
+            return false;
+        }
+
+        Instant end;
+        if (EndTime is { } endTime)
+        {
+            end = endTime.ToInstant();
+        }
+        else if (Duration is { } duration)
+        {
+            // Convert directly from period to duration
+            // because this is in UTC which always has
+            // the same days and weeks.
+            end = startInstant.Plus(duration.ToPeriod().ToDuration());
+        }
+        else
+        {
+            return false;
+        }
+
+        return end > value;
+    }
+
+    /// <summary>
+    /// CHecks if the given period is within the FREEBUSY entry.
+    /// </summary>
+    /// <param name="period"></param>
+    /// <returns></returns>
+    /// <exception cref="ArgumentException"></exception>
+    public bool CollidesWith(Period? period)
+    {
+        if (period is null)
+        {
+            return false;
+        }
+
+        if (period.StartTime.IsFloating)
+        {
+            throw new ArgumentException("Period start time must be in UTC");
+        }
+
+        var start = StartTime.ToInstant();
+        Instant end;
+        if (EndTime is { } endTime)
+        {
+            end = endTime.ToInstant();
+        }
+        else if (Duration is { } duration)
+        {
+            // Convert directly from period to duration
+            // because this is in UTC which always has
+            // the same days and weeks.
+            end = start.Plus(duration.ToPeriod().ToDuration());
+        }
+        else
+        {
+            return false;
+        }
+
+        var otherStart = period.StartTime.ToInstant();
+        Instant otherEnd;
+        if (period.EndTime is { } periodEndTime)
+        {
+            if (periodEndTime.IsFloating)
+            {
+                throw new ArgumentException("Period end time must be in UTC");
+            }
+
+            otherEnd = periodEndTime.ToInstant();
+        }
+        else if (period.Duration is { } periodDuration)
+        {
+            // Convert directly from period to duration
+            // because this is in UTC which always has
+            // the same days and weeks.
+            otherEnd = otherStart.Plus(periodDuration.ToPeriod().ToDuration());
+        }
+        else
+        {
+            throw new ArgumentException("Period must have a end time or duration");
+        }
+
+        return start < otherEnd && otherStart < end;
+    }
 }
diff --git a/Ical.Net/DataTypes/Occurrence.cs b/Ical.Net/DataTypes/Occurrence.cs
index 8826c1bdc..4ccf36b15 100644
--- a/Ical.Net/DataTypes/Occurrence.cs
+++ b/Ical.Net/DataTypes/Occurrence.cs
@@ -5,46 +5,106 @@
 
 using System;
 using Ical.Net.CalendarComponents;
+using Ical.Net.Evaluation;
+using Ical.Net.Utility;
+using NodaTime;
 
 namespace Ical.Net.DataTypes;
 
 public class Occurrence : IComparable<Occurrence>
 {
-    public Period Period { get; set; }
-    public IRecurrable Source { get; set; }
+    public IRecurrable Source { get; private set; }
+    public ZonedDateTime Start { get; private set; }
+    public ZonedDateTime End { get; private set; }
+
+    public (ZonedDateTime Start, ZonedDateTime End) Period => (Start, End);
 
     public Occurrence(Occurrence ao)
     {
-        Period = ao.Period;
         Source = ao.Source;
+        Start = ao.Start;
+        End = ao.End;
     }
 
-    public Occurrence(IRecurrable recurrable, Period period)
+    public Occurrence(IRecurrable recurrable, ZonedDateTime start, ZonedDateTime end)
     {
         Source = recurrable;
-        Period = period;
+        Start = start;
+        End = end;
     }
 
-    public bool Equals(Occurrence other) => Equals(Period, other.Period) && Equals(Source, other.Source);
+    public CalDateTime? DtStart
+    {
+        get
+        {
+            if (Source.Start is not { } dtStart)
+            {
+                return null;
+            }
 
-    public override bool Equals(object? obj)
+            var start = Start;
+            var tzid = dtStart.TimeZoneName;
+
+            // Switch to recurrable time zone, if any
+            if (tzid is not null)
+            {
+                start = start.WithZone(DateUtil.GetZone(tzid));
+            }
+
+            return dtStart.HasTime
+                ? new(start.LocalDateTime, tzid)
+                : new(start.Date, tzid);
+        }
+    }
+
+    /// <summary>
+    /// Checks if the given date time is contained within the period.
+    /// </summary>
+    public bool Contains(CalDateTime? value)
     {
-        if (ReferenceEquals(null, obj))
+        if (value is null)
         {
             return false;
         }
-        return obj is Occurrence occurrence && Equals(occurrence);
+
+        // Use floating time from the occurrence's time zone
+        var valueInstant = value
+            .ToZonedDateTime(Start.Zone)
+            .ToInstant();
+
+        return Start.ToInstant() <= valueInstant
+            && End.ToInstant() > valueInstant;
     }
 
-    public override int GetHashCode()
+    public bool Equals(Occurrence other)
     {
-        unchecked
+        return Start == other.Start
+            && End == other.End
+            && Source.Equals(other.Source);
+    }
+
+    public override bool Equals(object? obj)
+    {
+        if (obj is null)
         {
-            return ((Period.GetHashCode()) * 397) ^ (Source.GetHashCode());
+            return false;
         }
+
+        return obj is Occurrence occurrence && Equals(occurrence);
     }
 
-    public override string ToString() => $"Occurrence {Source.GetType().Name} ({Period.StartTime})";
+    public override int GetHashCode() => HashCode.Combine(Start, End, Source);
 
-    public int CompareTo(Occurrence? other) => Period.CompareTo(other?.Period);
+    public override string ToString() => $"Occurrence {Source.GetType().Name} ({Start})";
+
+    public int CompareTo(Occurrence? other)
+    {
+        if (other is null)
+        {
+            return 1;
+        }
+
+        // Order occurrences ONLY by instant, not time zone.
+        return Start.ToInstant().CompareTo(other.Start.ToInstant());
+    }
 }
diff --git a/Ical.Net/DataTypes/Period.cs b/Ical.Net/DataTypes/Period.cs
index d1271d669..1c6913b97 100644
--- a/Ical.Net/DataTypes/Period.cs
+++ b/Ical.Net/DataTypes/Period.cs
@@ -4,8 +4,8 @@
 //
 
 using System;
-using Ical.Net.Evaluation;
 using Ical.Net.Serialization.DataTypes;
+using NodaTime;
 
 namespace Ical.Net.DataTypes;
 
@@ -17,7 +17,7 @@ namespace Ical.Net.DataTypes;
 /// 2. by a start time and a duration,<br/>
 /// 3. by a start date/time or date-only, with the duration unspecified.
 /// </summary>
-public class Period : EncodableDataType, IComparable<Period>
+public class Period : EncodableDataType
 {
     private CalDateTime _startTime = null!;
     private CalDateTime? _endTime;
@@ -57,6 +57,9 @@ internal static Period Create(CalDateTime start, CalDateTime? end = null, Durati
     // Needed for the serialization factory
     internal Period() { }
 
+    internal Period(Instant start, Instant end)
+        : this(new CalDateTime(start), new CalDateTime(end)) { }
+
     /// <summary>
     /// Creates a new <see cref="Period"/> instance starting at the given time
     /// and ending at the given time.
@@ -78,8 +81,23 @@ public Period(CalDateTime start, CalDateTime? end = null)
             throw new ArgumentException(
                 $"Start time ({start}) and end time ({end}) must both have a time or both be date-only.");
 
-        if (end != null && end.LessThan(start))
-            throw new ArgumentException($"End time ({end}) must be greater than start time ({start}).", nameof(end));
+        if (end != null)
+        {
+            bool isEndBeforeStart;
+            if (end.IsFloating)
+            {
+                // Both are floating, compare local times
+                isEndBeforeStart = end.ToLocalDateTime() < start.ToLocalDateTime();
+            }
+            else
+            {
+                // Both are zoned, so compare instants
+                isEndBeforeStart = end.ToInstant() < start.ToInstant();
+            }
+
+            if (isEndBeforeStart)
+                throw new ArgumentException($"End time ({end}) must be greater than or equal to start time ({start}).", nameof(end));
+        }
 
         _startTime = start;
         _endTime = end;
@@ -114,8 +132,8 @@ public override void CopyFrom(ICopyable obj)
 
         if (obj is not Period p) return;
 
-        _startTime = p._startTime.Copy();
-        _endTime = p._endTime?.Copy();
+        _startTime = p._startTime;
+        _endTime = p._endTime;
         _duration = p._duration;
     }
 
@@ -130,16 +148,7 @@ public override bool Equals(object? obj)
     }
 
     /// <inheritdoc/>
-    public override int GetHashCode()
-    {
-        unchecked
-        {
-            var hashCode = StartTime.GetHashCode();
-            hashCode = (hashCode * 397) ^ (EndTime?.GetHashCode() ?? 0);
-            hashCode = (hashCode * 397) ^ Duration.GetHashCode();
-            return hashCode;
-        }
-    }
+    public override int GetHashCode() => HashCode.Combine(StartTime, EndTime, Duration);
 
     /// <inheritdoc/>
     public override string? ToString()
@@ -158,62 +167,12 @@ public override int GetHashCode()
     /// </summary>
     public virtual CalDateTime? EndTime => _endTime;
 
-    /// <summary>
-    /// Gets the end time of the period that was set, or - if this is <see langword="null"/> -
-    /// calculates the end time based by adding <see cref="EffectiveDuration"/> to the <see cref="StartTime"/>.
-    /// If <see cref="Duration"/> and <see cref="EndTime"/> are both <see langword="null"/>, the method returns <see langword="null"/>.
-    /// </summary>
-    public virtual CalDateTime? EffectiveEndTime
-    {
-        get =>
-            _endTime switch
-            {
-                null when _duration is null => null,
-                { } endTime => endTime,
-
-                // If _duration is not null, EffectiveDuration is not null
-                _ => CalculateEndTime()
-            };
-    }
-
-    private CalDateTime CalculateEndTime()
-    {
-        try
-        {
-            // When invoked, _duration is not null, so EffectiveDuration
-            // is guaranteed to be non-null
-            return _startTime.Add(EffectiveDuration!.Value);
-        }
-        catch (ArgumentOutOfRangeException)
-        {
-            // intentionally don't include the outer exception
-            throw new EvaluationOutOfRangeException($"Calculating the end time of the period from start time '{_startTime}' and effective duration '{EffectiveDuration}' resulted in an out-of-range value.");
-        }
-    }
-
     /// <summary>
     /// Gets the original duration of the period as it was set.<br/>
-    /// See also <seealso cref="EffectiveDuration"/>.
     /// </summary>
     public virtual Duration? Duration => _duration;
 
-    /// <summary>
-    /// Gets the duration of the period that was set, or - if this is <see langword="null"/> -
-    /// calculates the exact duration by subtracting <see cref="StartTime"/> from <see cref="EndTime"/>.
-    /// If <see cref="Duration"/> and <see cref="EndTime"/> are both <see langword="null"/>, the method returns <see langword="null"/>.
-    /// </summary>
-    public virtual Duration? EffectiveDuration
-    {
-        get =>
-            _duration switch
-            {
-                null when _endTime is null => null,
-                { } d => d,
-                _ => _endTime is { } endTime
-                    ? endTime.Subtract(_startTime)
-                    : null
-            };
-    }
+    public bool HasEndOrDuration => _duration is not null || _endTime is not null;
 
     internal string? TzId => _startTime.TzId; // same timezone for start and end
 
@@ -221,87 +180,12 @@ internal PeriodKind PeriodKind
     {
         get
         {
-            if (EffectiveDuration != null)
+            if (HasEndOrDuration)
             {
                 return PeriodKind.Period;
             }
 
-            return StartTime.HasTime ? PeriodKind.DateTime : PeriodKind.DateOnly;
-        }
-    }
-
-    /// <summary>
-    /// Checks if the given date time is contained within the period.
-    /// </summary>
-    /// <remarks>
-    /// The method is timezone-aware.
-    /// </remarks>
-    /// <param name="dt"></param>
-    public virtual bool Contains(CalDateTime? dt)
-    {
-        // Start time is inclusive
-        if (dt == null || !_startTime.LessThanOrEqual(dt))
-        {
-            return false;
-        }
-
-        // End time is exclusive
-        return EffectiveEndTime?.GreaterThan(dt) != false;
-    }
-
-    /// <summary>
-    /// Checks if the start time of the given period is contained within the current period
-    /// or if the end time of the given period is contained within the current period.
-    /// It also checks the case where the given period completely overlaps the current period.
-    /// </summary>
-    /// <remarks>
-    /// The method is timezone-aware.
-    /// </remarks>
-    /// <param name="period"></param>
-    /// <returns></returns>
-    public virtual bool CollidesWith(Period? period)
-    {
-        if (period is null) return false;
-
-        if (EffectiveDuration is null || period.EffectiveDuration is null)
-        {
-            throw new ArgumentException("Both periods must have a defined (non-null) duration to check for collisions. For collisions with date/time use Contains().", nameof(period));
-        }
-
-        var thisStart = StartTime;
-        var thisEnd = EffectiveEndTime;
-        var otherStart = period.StartTime;
-        var otherEnd = period.EffectiveEndTime;
-
-        // Periods without a duration are not colliding
-        if (EffectiveDuration.Value.IsZero || period.EffectiveDuration.Value.IsZero)
-        {
-            return false;
-        }
-
-        // Periods overlap if their start and end times are overlapping.
-        // End time is exclusive.
-        return thisStart.LessThan(otherEnd) && otherStart.LessThan(thisEnd);
-    }
-
-    /// <inheritdoc/>
-    public int CompareTo(Period? other)
-    {
-        if (other == null)
-        {
-            return 1;
-        }
-
-        if (StartTime.AsUtc.Equals(other.StartTime.AsUtc))
-        {
-            return 0;
-        }
-        if (StartTime.LessThanOrEqual(other.StartTime))
-        {
-            return -1;
+            return _startTime.HasTime ? PeriodKind.DateTime : PeriodKind.DateOnly;
         }
-
-        // StartTime is greater than other.StartTime
-        return 1;
     }
 }
diff --git a/Ical.Net/DataTypes/RecurrenceIdentifier.cs b/Ical.Net/DataTypes/RecurrenceIdentifier.cs
index c446558f3..cf511ee81 100644
--- a/Ical.Net/DataTypes/RecurrenceIdentifier.cs
+++ b/Ical.Net/DataTypes/RecurrenceIdentifier.cs
@@ -65,7 +65,7 @@ public int CompareTo(RecurrenceIdentifier? other)
             return 1;
         }
 
-        var startComparison = StartTime.CompareTo(other.StartTime);
+        var startComparison = StartTime.ToInstant().CompareTo(other.StartTime.ToInstant());
         if (startComparison != 0)
         {
             return startComparison;
diff --git a/Ical.Net/DataTypes/RequestStatus.cs b/Ical.Net/DataTypes/RequestStatus.cs
index 2e8c621cb..0bc192a23 100644
--- a/Ical.Net/DataTypes/RequestStatus.cs
+++ b/Ical.Net/DataTypes/RequestStatus.cs
@@ -3,6 +3,7 @@
 // Licensed under the MIT license.
 //
 
+using System;
 using System.IO;
 using Ical.Net.Serialization.DataTypes;
 
@@ -86,14 +87,5 @@ public override bool Equals(object? obj)
         return Equals((RequestStatus) obj);
     }
 
-    public override int GetHashCode()
-    {
-        unchecked
-        {
-            var hashCode = _mDescription?.GetHashCode() ?? 0;
-            hashCode = (hashCode * 397) ^ (_mExtraData?.GetHashCode() ?? 0);
-            hashCode = (hashCode * 397) ^ (_mStatusCode?.GetHashCode() ?? 0);
-            return hashCode;
-        }
-    }
+    public override int GetHashCode() => HashCode.Combine(_mDescription, _mExtraData, _mStatusCode);
 }
diff --git a/Ical.Net/DataTypes/Trigger.cs b/Ical.Net/DataTypes/Trigger.cs
index 38bad1ef9..d20cdbf07 100644
--- a/Ical.Net/DataTypes/Trigger.cs
+++ b/Ical.Net/DataTypes/Trigger.cs
@@ -3,7 +3,6 @@
 // Licensed under the MIT license.
 //
 
-using System;
 using System.IO;
 using Ical.Net.Serialization.DataTypes;
 
@@ -36,7 +35,7 @@ public virtual CalDateTime? DateTime
             // Ensure date/time has a time part
             if (!_mDateTime.HasTime)
             {
-                _mDateTime = new CalDateTime(_mDateTime.Date, new TimeOnly(), _mDateTime.TzId);
+                _mDateTime = new CalDateTime(_mDateTime.Date, new NodaTime.LocalTime(), _mDateTime.TzId);
             }
         }
     }
@@ -88,7 +87,7 @@ public override void CopyFrom(ICopyable obj)
             return;
         }
 
-        DateTime = t.DateTime?.Copy();
+        DateTime = t.DateTime;
         Duration = t.Duration;
         Related = t.Related;
     }
diff --git a/Ical.Net/DataTypes/WeekDay.cs b/Ical.Net/DataTypes/WeekDay.cs
index 2db120326..23fd9193b 100644
--- a/Ical.Net/DataTypes/WeekDay.cs
+++ b/Ical.Net/DataTypes/WeekDay.cs
@@ -57,7 +57,7 @@ public override bool Equals(object? obj)
         return weekday.Offset == Offset && weekday.DayOfWeek == DayOfWeek;
     }
 
-    public override int GetHashCode() => (Offset ?? 0).GetHashCode() ^ DayOfWeek.GetHashCode();
+    public override int GetHashCode() => HashCode.Combine(Offset, DayOfWeek);
 
     /// <inheritdoc/>
     public override void CopyFrom(ICopyable obj)
diff --git a/Ical.Net/Evaluation/EvaluationPeriod.cs b/Ical.Net/Evaluation/EvaluationPeriod.cs
new file mode 100644
index 000000000..4afb8550a
--- /dev/null
+++ b/Ical.Net/Evaluation/EvaluationPeriod.cs
@@ -0,0 +1,66 @@
+//
+// Copyright ical.net project maintainers and contributors.
+// Licensed under the MIT license.
+//
+
+using System;
+using NodaTime;
+
+namespace Ical.Net.Evaluation;
+
+public sealed class EvaluationPeriod : IComparable<EvaluationPeriod>, IEquatable<EvaluationPeriod>
+{
+    public ZonedDateTime Start { get; private set; }
+    public ZonedDateTime? End { get; private set; }
+
+    public EvaluationPeriod(ZonedDateTime start, ZonedDateTime? end = null)
+    {
+        if (end != null)
+        {
+            if (start.Zone.Id != end.Value.Zone.Id)
+            {
+                throw new ArgumentException("End time zone must equal start time zone", nameof(end));
+            }
+
+            if (end.Value.ToInstant() < start.ToInstant())
+            {
+                throw new ArgumentException("End time must be greater or equal to start time", nameof(end));
+            }
+        }
+
+        Start = start;
+        End = end;
+    }
+
+    public EvaluationPeriod WithZone(DateTimeZone zone)
+    {
+        return new(Start.WithZone(zone), End?.WithZone(zone));
+    }
+
+    public bool Equals(EvaluationPeriod? other)
+    {
+        return other is not null && Start == other.Start && End == other.End;
+    }
+
+    public override bool Equals(object? obj)
+    {
+        if (obj is null)
+        {
+            return false;
+        }
+
+        return obj is EvaluationPeriod value && Equals(value);
+    }
+
+    public override int GetHashCode() => HashCode.Combine(Start, End);
+
+    public int CompareTo(EvaluationPeriod? other)
+    {
+        if (other == null)
+        {
+            return 1;
+        }
+
+        return Start.ToInstant().CompareTo(other.Start.ToInstant());
+    }
+}
diff --git a/Ical.Net/Evaluation/Evaluator.cs b/Ical.Net/Evaluation/Evaluator.cs
index c9267df55..fc715be46 100644
--- a/Ical.Net/Evaluation/Evaluator.cs
+++ b/Ical.Net/Evaluation/Evaluator.cs
@@ -6,13 +6,15 @@
 using System;
 using System.Collections.Generic;
 using Ical.Net.DataTypes;
-using Ical.Net.Utility;
+using NodaTime;
+using NodaTime.Extensions;
+using NodaTime.TimeZones;
 
 namespace Ical.Net.Evaluation;
 
 public abstract class Evaluator : IEvaluator
 {
-    protected void IncrementDate(ref CalDateTime dt, RecurrencePattern pattern, int interval)
+    protected static void IncrementDate(ref ZonedDateTime dt, RecurrencePattern pattern, int interval)
     {
         if (interval == 0)
             return;
@@ -23,27 +25,43 @@ protected void IncrementDate(ref CalDateTime dt, RecurrencePattern pattern, int
             switch (pattern.Frequency)
             {
                 case FrequencyType.Secondly:
-                    dt = old.AddSeconds(interval);
+                    dt = old.PlusSeconds(interval);
                     break;
                 case FrequencyType.Minutely:
-                    dt = old.AddMinutes(interval);
+                    dt = old.PlusMinutes(interval);
                     break;
                 case FrequencyType.Hourly:
-                    dt = old.AddHours(interval);
+                    dt = old.PlusHours(interval);
                     break;
                 case FrequencyType.Daily:
-                    dt = old.AddDays(interval);
+                    dt = old.LocalDateTime
+                        .PlusDays(interval)
+                        .InZoneLeniently(old.Zone);
                     break;
                 case FrequencyType.Weekly:
-                    dt = DateUtil.AddWeeks(old, interval, pattern.FirstDayOfWeek);
+                    var isoDayOfWeek = pattern.FirstDayOfWeek.ToIsoDayOfWeek();
+                    if (old.Date.DayOfWeek != isoDayOfWeek)
+                    {
+                        old = old.LocalDateTime
+                            .Previous(isoDayOfWeek)
+                            .InZoneLeniently(old.Zone);
+                    }
+
+                    dt = old.LocalDateTime
+                        .PlusWeeks(interval)
+                        .InZoneLeniently(old.Zone);
                     break;
                 case FrequencyType.Monthly:
-                    dt = old.AddDays(-old.Day + 1).AddMonths(interval);
+                    dt = old.LocalDateTime
+                        .PlusDays(-old.Day + 1)
+                        .PlusMonths(interval)
+                        .InZoneLeniently(old.Zone);
                     break;
                 case FrequencyType.Yearly:
-                    // RecurrencePatternEvaluator relies on the assumption that after incrementing, the new refDate
-                    // is usually at the first day of an interval.
-                    dt = old.AddDays(-old.DayOfYear + 1).AddYears(interval);
+                    dt = old.LocalDateTime
+                        .PlusDays(-old.DayOfYear + 1)
+                        .PlusYears(interval)
+                        .InZoneLeniently(old.Zone);
                     break;
                 default:
                     // Frequency should always be valid at this stage.
@@ -58,5 +76,10 @@ protected void IncrementDate(ref CalDateTime dt, RecurrencePattern pattern, int
         }
     }
 
-    public abstract IEnumerable<Period> Evaluate(CalDateTime referenceDate, CalDateTime? periodStart, EvaluationOptions? options);
+    public virtual IEnumerable<EvaluationPeriod> Evaluate(CalDateTime referenceDate, ZonedDateTime periodStart, EvaluationOptions? options)
+    {
+        return Evaluate(referenceDate, periodStart.Zone, periodStart.ToInstant(), options);
+    }
+
+    public abstract IEnumerable<EvaluationPeriod> Evaluate(CalDateTime referenceDate, DateTimeZone timeZone, Instant? periodStart, EvaluationOptions? options);
 }
diff --git a/Ical.Net/Evaluation/EventEvaluator.cs b/Ical.Net/Evaluation/EventEvaluator.cs
index 74a97504d..bddf53401 100644
--- a/Ical.Net/Evaluation/EventEvaluator.cs
+++ b/Ical.Net/Evaluation/EventEvaluator.cs
@@ -4,10 +4,8 @@
 //
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using Ical.Net.CalendarComponents;
-using Ical.Net.DataTypes;
+using NodaTime;
 
 namespace Ical.Net.Evaluation;
 
@@ -18,75 +16,119 @@ public class EventEvaluator : RecurringEvaluator
 {
     protected CalendarEvent CalendarEvent => (CalendarEvent) Recurrable;
 
-    protected override Duration? DefaultDuration => CalendarEvent.EffectiveDuration;
-
     /// <summary>
     /// Initializes a new instance of the <see cref="EventEvaluator"/> class.
     /// </summary>
     /// <param name="evt"></param>
     public EventEvaluator(CalendarEvent evt) : base(evt) { }
 
-    /// <summary>
-    /// Evaluates this event to determine the dates and times for which the event occurs.
-    /// This method only evaluates events which occur at or after<paramref name="periodStart"/>.
-    /// </summary>
-    /// <remarks>
-    /// For events with very complex recurrence rules, this method may be a bottleneck
-    /// during processing time, especially when this method in called for a large number
-    /// of events, in sequence, or for a very large time span.
-    /// </remarks>
-    /// <param name="referenceDate"></param>
-    /// <param name="periodStart">The beginning date of the range to evaluate.</param>
-    /// <param name="options"></param>
-    /// <returns></returns>
-    public override IEnumerable<Period> Evaluate(CalDateTime referenceDate, CalDateTime? periodStart, EvaluationOptions? options)
-    {
-        // Evaluate recurrences normally
-        var periods = base.Evaluate(referenceDate, periodStart, options)
-            .Select(WithFinalDuration);
+    protected override EvaluationPeriod EvaluateRDate(DataTypes.Period rdate, DateTimeZone referenceTimeZone)
+	{
+		var start = rdate.StartTime.AsZonedOrDefault(referenceTimeZone);
 
-        return periods;
-    }
+		ZonedDateTime? end = null;
+		if (rdate.Duration is { } duration)
+		{
+			if (!rdate.StartTime.HasTime && duration.HasTime)
+			{
+				throw new EvaluationException($"Unable to add time to date-only RDATE {rdate}");
+			}
 
-    /// <summary>
-    /// The <paramref name="period"/> to evaluate has the <see cref="Period.StartTime"/> set,
-    /// but neither <see cref="Period.EndTime"/> nor <see cref="Period.Duration"/> are set.
-    /// </summary>
-    /// <param name="period">The period where <see cref="Period.Duration"/> will be set.</param>
-    /// <returns>Returns the <paramref name="period"/> with <see cref="Period.Duration"/> and exact <see cref="Period.EffectiveEndTime"/> set.</returns>
-    private Period WithFinalDuration(Period period)
+			end = start.LocalDateTime
+				.Plus(duration.GetNominalPart())
+				.InZoneRelativeTo(start)
+				.Plus(duration.GetTimePart());
+		}
+		else if (rdate.EndTime is { } dtEnd)
+		{
+			var exactDuration = dtEnd.ToInstant() - rdate.StartTime.ToInstant();
+
+			if (exactDuration < Duration.Zero)
+			{
+				throw new InvalidOperationException("DtEnd is before DtStart");
+			}
+
+			end = start.Plus(exactDuration);
+		}
+		else
+		{
+			if (!rdate.StartTime.HasTime
+				&& CalendarEvent.Duration is { } eventDuration
+				&& eventDuration.HasTime)
+			{
+				throw new EvaluationException($"Unable to add time to date-only RDATE {rdate}");
+			}
+
+			// Use event
+			end = GetEnd(start);
+		}
+
+		return new EvaluationPeriod(start, end);
+	}
+
+    protected override ZonedDateTime GetEnd(ZonedDateTime start)
     {
-        try
+        if (CalendarEvent.Duration is { } duration)
         {
-            /*
-               The period's Duration evaluates the event's definition of DtStart
-               and Duration, or the timespan from DtStart to DtEnd.
+            // Add nominal values (weeks & days) to local time
+            // and then add accurate time to zoned time.
+            return start.LocalDateTime
+                .Plus(duration.GetNominalPart())
+                .InZoneRelativeTo(start)
+                .Plus(duration.GetTimePart());
+        }
 
-               The time span is used, because the period end time gets the same timezone as the event end time.
-               This ensures that the end time is correct, even for DST transitions.
+        if (CalendarEvent.DtStart is not { } dtStart)
+        {
+            throw new InvalidOperationException("DtStart must be set.");
+        }
 
-               The exact duration is calculated from the zoned end time and the zoned start time,
-               and it may differ from the time span added to the period start time.
-             */
+        if (CalendarEvent.DtEnd is { } dtEnd)
+        {
+            // The spec says DtEnd MUST be the same type as DtStart.
+            // Some cases can be reasonably handled though.
 
-            // The preliminary duration was set in a previous evaluation step
-            var duration = period.Duration;
+            // Assume a floating end is in the time zone of the event.
+            if (dtEnd.IsFloating && !dtStart.IsFloating)
+            {
+                dtEnd = dtEnd.ToTimeZone(dtStart.TimeZoneName);
+            }
 
-            if (duration == null)
+            // The spec says specifying DTEND results in exact time,
+            // but tests say that all day events should be treated
+            // as a nominal duration.
+            if (!dtStart.HasTime && !dtEnd.HasTime)
             {
-                duration = CalendarEvent.EffectiveDuration;
+                // Calculate nominal duration between dates
+                var nominalDuration = dtEnd.ToTimeZone(dtStart.TimeZoneName)
+                    .ToZonedDateTime()
+                    .Date
+                    .Minus(dtStart.ToZonedDateTime().Date);
+
+                return start.LocalDateTime
+                    .Plus(nominalDuration)
+                    .InZoneRelativeTo(start);
             }
 
-            var newPeriod = new Period(
-                start: period.StartTime,
-                duration: duration.Value);
+            var exactDuration = dtEnd.ToInstant() - dtStart.ToInstant();
+
+            if (exactDuration < Duration.Zero)
+            {
+                throw new InvalidOperationException("DtEnd is before DtStart");
+            }
 
-            return newPeriod;
+            return start.Plus(exactDuration);
         }
-        catch (ArgumentOutOfRangeException)
+
+        if (!dtStart.HasTime)
         {
-            // intentionally don't include the outer exception
-            throw new EvaluationOutOfRangeException("Evaluation aborted: Calculating the end time of the event occurrence resulted in an out-of-range value. This commonly happens when trying to enumerate an unbounded RRULE to its end. Consider applying the .TakeWhile() operator.");
+            // Spec says to assume duration is one day date only (nominal, not 24 hours) 
+            return start.LocalDateTime
+                .Plus(Period.FromDays(1))
+                .InZoneRelativeTo(start);
         }
+
+        // Event ends as it starts
+        return start;
     }
 }
diff --git a/Ical.Net/Evaluation/IEvaluator.cs b/Ical.Net/Evaluation/IEvaluator.cs
index d1a646c2c..bd2c7db22 100644
--- a/Ical.Net/Evaluation/IEvaluator.cs
+++ b/Ical.Net/Evaluation/IEvaluator.cs
@@ -6,6 +6,7 @@
 using System;
 using System.Collections.Generic;
 using Ical.Net.DataTypes;
+using NodaTime;
 
 namespace Ical.Net.Evaluation;
 
@@ -34,5 +35,6 @@ public interface IEvaluator
     ///     A sequence of <see cref="Ical.Net.DataTypes.Period"/> objects for
     ///     each date/time when this item occurs/recurs.
     /// </returns>
-    IEnumerable<Period> Evaluate(CalDateTime referenceDate, CalDateTime? periodStart, EvaluationOptions? options);
+    IEnumerable<EvaluationPeriod> Evaluate(CalDateTime referenceDate, DateTimeZone timeZone, Instant? periodStart, EvaluationOptions? options);
+    IEnumerable<EvaluationPeriod> Evaluate(CalDateTime referenceDate, ZonedDateTime periodStart, EvaluationOptions? options);
 }
diff --git a/Ical.Net/Evaluation/RecurrencePatternEvaluator.cs b/Ical.Net/Evaluation/RecurrencePatternEvaluator.cs
index 7decd808d..c6dd45ecf 100644
--- a/Ical.Net/Evaluation/RecurrencePatternEvaluator.cs
+++ b/Ical.Net/Evaluation/RecurrencePatternEvaluator.cs
@@ -8,18 +8,14 @@
 using System.Diagnostics;
 using System.Linq;
 using Ical.Net.DataTypes;
+using NodaTime;
+using NodaTime.Calendars;
+using NodaTime.Extensions;
 
 namespace Ical.Net.Evaluation;
 
 public class RecurrencePatternEvaluator : Evaluator
 {
-    /// <summary>
-    /// The system calendar to be used to calculate details like the week of the year, days in a month, etc.
-    /// We only support the gregorian calendar at this time. We take it from the InvariantCulture to avoid
-    /// any side effects from the local system's configuration.
-    /// </summary>
-    private static System.Globalization.Calendar Calendar { get; } = System.Globalization.CultureInfo.InvariantCulture.Calendar;
-
     protected RecurrencePattern Pattern { get; set; }
 
     public RecurrencePatternEvaluator(RecurrencePattern pattern)
@@ -114,32 +110,40 @@ private RecurrencePattern ProcessRecurrencePattern(CalDateTime referenceDate)
     /// For example, if the search start date (start) is Wed, Mar 23, 12:19PM, but the recurrence is Mon - Fri, 9:00AM - 5:00PM,
     /// the start dates returned should all be at 9:00AM, and not 12:19PM.
     /// </summary>
-    private IEnumerable<CalDateTime> GetDates(CalDateTime seed, CalDateTime? periodStart, RecurrencePattern pattern,
+    private IEnumerable<ZonedDateTime> GetDates(CalDateTime seed, DateTimeZone timeZone, Instant? periodStart, RecurrencePattern pattern,
          EvaluationOptions? options)
     {
-        var originalDate = seed;
-        var seedCopy = seed;
-        var periodStartDt = periodStart?.ToTimeZone(seed.TzId);
+        // Floating values should be evaluated in the given time zone.
+        // Other values should be evaluated in their time zone and then
+        // converted to the given time zone.
+        var originalDate = seed.AsZonedOrDefault(timeZone);
+
+        var seedCopy = originalDate;
+
+        var periodStartDt = periodStart?.InZone(originalDate.Zone);
+
+        var weekYearRule = GetWeekYearRule(pattern);
 
         if ((pattern.Frequency == FrequencyType.Yearly) && (pattern.ByWeekNo.Count != 0))
         {
             // Dates in the first or last week of the year could belong weeks that belong to
             // the prev/next year, in which case we must adjust that year. This is necessary
             // to get the intervals right.
-            IncrementDate(ref seedCopy, pattern, Calendar.GetIso8601YearOfWeek(seedCopy, pattern.FirstDayOfWeek) - seedCopy.Year);
+            IncrementDate(ref seedCopy, pattern, weekYearRule.GetWeekYear(seedCopy.Date) - seedCopy.Year);
         }
 
         // optimize the start time for selecting candidates
         // (only applicable where a COUNT is not specified)
-        if (pattern.Count is null)
+        if (pattern.Count is null && periodStartDt is not null)
         {
             var incremented = seedCopy;
-            while (incremented < periodStartDt)
+            while (incremented.ToInstant() < periodStartDt.Value.ToInstant())
             {
                 seedCopy = incremented;
                 IncrementDate(ref incremented, pattern, pattern.Interval);
             }
-        } else
+        }
+        else
         {
             if (pattern.Count < 1)
                 throw new Exception("Count must be greater than 0");
@@ -148,43 +152,41 @@ private IEnumerable<CalDateTime> GetDates(CalDateTime seed, CalDateTime? periodS
         // Do the enumeration in a separate method, as it is a generator method that is
         // only executed after enumeration started. In order to do most validation upfront,
         // do as many steps outside the generator as possible.
-        return EnumerateDates(originalDate, seedCopy, pattern, options);
+        return EnumerateDates(originalDate, seedCopy, pattern, options)
+            .Select(x => x.WithZone(timeZone));
     }
 
-    private IEnumerable<CalDateTime> EnumerateDates(CalDateTime originalDate, CalDateTime intervalRefTime, RecurrencePattern pattern, EvaluationOptions? options)
+    private IEnumerable<ZonedDateTime> EnumerateDates(ZonedDateTime originalDate, ZonedDateTime intervalRefTime, RecurrencePattern pattern, EvaluationOptions? options)
     {
         var expandBehavior = RecurrenceUtil.GetExpandBehaviorList(pattern);
 
-        var searchEndDate = GetSearchEndDate(pattern);
+        var searchEndDate = GetSearchEndDate(pattern, originalDate.Zone);
 
         var noCandidateIncrementCount = 0;
 
         var dateCount = 0;
+
         while (true)
         {
             var lowerLimit = GetIntervalLowerLimit(intervalRefTime, pattern, originalDate);
 
-            if (searchEndDate < lowerLimit)
+            if (searchEndDate != null && searchEndDate.Value.ToInstant() < lowerLimit.ToInstant())
                 break;
 
-            var candidates =
-                GetCandidates((lowerLimit > intervalRefTime) ? lowerLimit : intervalRefTime, pattern, expandBehavior);
+            var seedDate = (lowerLimit.ToInstant() > intervalRefTime.ToInstant()) ? lowerLimit : intervalRefTime;
+            var candidates = GetCandidates(seedDate, pattern, expandBehavior);
 
-            foreach (var t in candidates.Where(t => t >= originalDate))
+            foreach (var candidate in candidates.Where(t => t.ToInstant() >= originalDate.ToInstant()))
             {
                 noCandidateIncrementCount = 0;
-                var candidate = t;
 
                 // candidates MAY occur before periodStart
                 // For example, FREQ=YEARLY;BYWEEKNO=1 could return dates
                 // from the previous year.
 
-                // UNTIL is applied outside of this method, after TZ conversion has been applied.
-
                 yield return candidate;
-                dateCount++;
 
-                if (dateCount >= pattern.Count)
+                if (++dateCount >= pattern.Count)
                     yield break;
             }
 
@@ -197,14 +199,17 @@ private IEnumerable<CalDateTime> EnumerateDates(CalDateTime originalDate, CalDat
         }
     }
 
-    private static CalDateTime? GetSearchEndDate(RecurrencePattern pattern)
+    private static ZonedDateTime? GetSearchEndDate(RecurrencePattern pattern, DateTimeZone timeZone)
     {
         // This value is only used for performance reasons to stop incrementing after
         // until is passed, even if no recurrences are being found.
         // As a safe heuristic we add 1d to the UNTIL value to cover any time shift and DST changes.
         // It's just important that we don't miss any recurrences, not that we stop exactly at UNTIL.
         // Precise UNTIL handling is done outside this method after TZ conversion.
-        var coarseUntil = pattern.Until?.AddDays(1);
+        var coarseUntil = pattern.Until?.ToZonedDateTime(timeZone)
+            .LocalDateTime
+            .PlusDays(1)
+            .InZoneLeniently(timeZone);
 
         return coarseUntil;
     }
@@ -225,7 +230,7 @@ private IEnumerable<CalDateTime> EnumerateDates(CalDateTime originalDate, CalDat
     ///   start to the first day of the configured week so we don't miss candidates
     ///   that belong to the week containing Jan 1st.
     /// </remarks>
-    private static CalDateTime GetIntervalLowerLimit(CalDateTime intervalRefTime, RecurrencePattern pattern, CalDateTime originalDate)
+    private static ZonedDateTime GetIntervalLowerLimit(ZonedDateTime intervalRefTime, RecurrencePattern pattern, ZonedDateTime originalDate)
     {
         switch (pattern)
         {
@@ -238,9 +243,9 @@ private static CalDateTime GetIntervalLowerLimit(CalDateTime intervalRefTime, Re
                 // to perform month-end semantics (e.g. Jan 31 -> Feb 28/29) instead of
                 // manually clamping the day.
                 var monthDelta = originalDate.Month - intervalRefTime.Month;
-                var adjusted = intervalRefTime.AddMonths(monthDelta);
-
-                return new CalDateTime(adjusted.Year, adjusted.Month, adjusted.Day, adjusted.Hour, adjusted.Minute, adjusted.Second, intervalRefTime.TzId);
+                return intervalRefTime.LocalDateTime
+                    .PlusMonths(monthDelta)
+                    .InZoneLeniently(intervalRefTime.Zone);
             }
 
             case { Frequency: FrequencyType.Yearly, ByMonth.Count: > 0, ByWeekNo.Count: 0 }:
@@ -267,7 +272,7 @@ private static CalDateTime GetIntervalLowerLimit(CalDateTime intervalRefTime, Re
                 var month = pattern.ByMonth.Min();
 
                 // Determine an appropriate day in the month.
-                var daysInMonth = Calendar.GetDaysInMonth(year, month);
+                var daysInMonth = CalendarSystem.Iso.GetDaysInMonth(year, month);
                 int day;
                 if (pattern.ByMonthDay.Count > 0)
                 {
@@ -289,7 +294,8 @@ private static CalDateTime GetIntervalLowerLimit(CalDateTime intervalRefTime, Re
                 var minute = pattern.ByMinute.Count > 0 ? pattern.ByMinute.Min() : originalDate.Minute;
                 var second = pattern.BySecond.Count > 0 ? pattern.BySecond.Min() : originalDate.Second;
 
-                return new CalDateTime(year, month, day, hour, minute, second, intervalRefTime.TzId);
+                return new LocalDateTime(year, month, day, hour, minute, second)
+                    .InZoneLeniently(intervalRefTime.Zone);
             }
 
             case { Frequency: FrequencyType.Yearly, ByWeekNo.Count: not 0 }:
@@ -297,7 +303,8 @@ private static CalDateTime GetIntervalLowerLimit(CalDateTime intervalRefTime, Re
                 // YEARLY with BYWEEKNO: weeks may span year boundaries. Move the
                 // interval lower limit to the first day of the week so expansion over
                 // the week (including days before Jan 1st) is handled correctly.
-                return GetFirstDayOfWeekDate(intervalRefTime, pattern.FirstDayOfWeek);
+                return GetFirstDayOfWeekDate(intervalRefTime.LocalDateTime, pattern.FirstDayOfWeek)
+                    .InZoneLeniently(intervalRefTime.Zone);
             }
 
             default:
@@ -328,16 +335,17 @@ private struct ExpandContext
     /// <param name="pattern"></param>
     /// <param name="expandBehaviors"></param>
     /// <returns>A list of possible dates.</returns>
-    private IEnumerable<CalDateTime> GetCandidates(CalDateTime seedDate, RecurrencePattern pattern, bool?[] expandBehaviors)
+    private IEnumerable<ZonedDateTime> GetCandidates(ZonedDateTime seedDate, RecurrencePattern pattern, bool?[] expandBehaviors)
     {
         var expandContext = new ExpandContext { IsCandidateSetFullyExpanded = false };
 
-        IEnumerable<CalDateTime> dates = [seedDate];
+        IEnumerable<ZonedDateTime> dates = [seedDate];
         dates = GetMonthVariants(dates, pattern, expandBehaviors[0]);
         dates = GetWeekNoVariants(dates, pattern, expandBehaviors[1], ref expandContext);
         dates = GetYearDayVariants(dates, pattern, expandBehaviors[2], ref expandContext);
         dates = GetMonthDayVariants(dates, pattern, expandBehaviors[3], ref expandContext);
         dates = GetDayVariants(dates, pattern, expandBehaviors[4], ref expandContext);
+
         dates = GetHourVariants(dates, pattern, expandBehaviors[5]);
         dates = GetMinuteVariants(dates, pattern, expandBehaviors[6]);
         dates = GetSecondVariants(dates, pattern, expandBehaviors[7]);
@@ -352,23 +360,21 @@ private IEnumerable<CalDateTime> GetCandidates(CalDateTime seedDate, RecurrenceP
     /// </summary>
     /// <param name="dates">The list of dates to which the BYSETPOS rules will be applied.</param>
     /// <param name="pattern"></param>
-    private static IEnumerable<CalDateTime> ApplySetPosRules(IEnumerable<CalDateTime> dates, RecurrencePattern pattern)
+    private static IEnumerable<T> ApplySetPosRules<T>(IEnumerable<T> dates, RecurrencePattern pattern)
     {
         // return if no SETPOS rules specified..
         if (pattern.BySetPosition.Count == 0)
             return dates;
 
-        ISet<int> bySetPos;
+        HashSet<int> bySetPos;
 
         if (pattern.BySetPosition.Any(p => p < 0)) {
             var tmp = dates.ToList();
             var count = tmp.Count;
             dates = tmp;
-            bySetPos = new HashSet<int>(
-                pattern.BySetPosition
-                .Select(p => (p < 0) ? count + p + 1 : p));
+            bySetPos = [.. pattern.BySetPosition.Select(p => (p < 0) ? count + p + 1 : p)];
         } else {
-            bySetPos = new HashSet<int>(pattern.BySetPosition);
+            bySetPos = [.. pattern.BySetPosition];
         }
 
         return dates.Where((d, i) => bySetPos.Contains(i + 1));
@@ -382,7 +388,7 @@ private static IEnumerable<CalDateTime> ApplySetPosRules(IEnumerable<CalDateTime
     /// <param name="pattern"></param>
     /// <param name="expand"></param>
     /// <returns>The modified list of dates after applying the BYMONTH rules.</returns>
-    private static IEnumerable<CalDateTime> GetMonthVariants(IEnumerable<CalDateTime> dates, RecurrencePattern pattern, bool? expand)
+    private static IEnumerable<ZonedDateTime> GetMonthVariants(IEnumerable<ZonedDateTime> dates, RecurrencePattern pattern, bool? expand)
     {
         if (expand == null || pattern.ByMonth.Count == 0)
             return dates;
@@ -390,8 +396,8 @@ private static IEnumerable<CalDateTime> GetMonthVariants(IEnumerable<CalDateTime
         if (expand.Value)
         {
             // Expand behavior
-            return dates
-                .SelectMany(d => pattern.ByMonth.Select(month => d.AddMonths(month - d.Month)));
+            return dates.SelectMany(d => pattern.ByMonth
+                .Select(month => d.LocalDateTime.PlusMonths(month - d.Month).InZoneLeniently(d.Zone)));
         }
 
         // Limit behavior
@@ -401,7 +407,7 @@ private static IEnumerable<CalDateTime> GetMonthVariants(IEnumerable<CalDateTime
             // start of a week except for the initial reference date.
             // Return weeks that have any day within BYMONTH.
             return dates.Where(date => pattern.ByMonth.Contains(date.Month)
-                || pattern.ByMonth.Contains(date.AddDays(6).Month));
+                || pattern.ByMonth.Contains(date.LocalDateTime.PlusDays(6).InZoneLeniently(date.Zone).Month));
         }
 
         return dates.Where(date => pattern.ByMonth.Contains(date.Month));
@@ -413,7 +419,7 @@ private static IEnumerable<CalDateTime> GetMonthVariants(IEnumerable<CalDateTime
     /// </summary>
     /// <param name="dates">The list of dates to which the BYWEEKNO rules will be applied.</param>
     /// <returns>The modified list of dates after applying the BYWEEKNO rules.</returns>
-    private static IEnumerable<CalDateTime> GetWeekNoVariants(IEnumerable<CalDateTime> dates, RecurrencePattern pattern, bool? expand, ref ExpandContext expandContext)
+    private static IEnumerable<ZonedDateTime> GetWeekNoVariants(IEnumerable<ZonedDateTime> dates, RecurrencePattern pattern, bool? expand, ref ExpandContext expandContext)
     {
         if (expand == null || pattern.ByWeekNo.Count == 0)
             return dates;
@@ -431,47 +437,60 @@ private static IEnumerable<CalDateTime> GetWeekNoVariants(IEnumerable<CalDateTim
         return GetMonthVariants(weekNoDates, pattern, expand: false);
     }
 
-    private static IEnumerable<CalDateTime> GetWeekNoVariantsExpanded(IEnumerable<CalDateTime> dates, RecurrencePattern pattern)
+    private static IWeekYearRule GetWeekYearRule(RecurrencePattern pattern) =>
+        WeekYearRules.ForMinDaysInFirstWeek(4, pattern.FirstDayOfWeek.ToIsoDayOfWeek());
+
+    private static IEnumerable<ZonedDateTime> GetWeekNoVariantsExpanded(IEnumerable<ZonedDateTime> dates, RecurrencePattern pattern)
     {
+        var weekYearRule = GetWeekYearRule(pattern);
+
         foreach (var (t, weekNo) in dates.SelectMany(t => GetByWeekNoForYearNormalized(pattern, t.Year), (t, weekNo) => (t, weekNo)))
         {
-            var date = t;
+            var date = t.LocalDateTime;
 
             // Make sure we start from a reference date that is in a week that belongs to the current year.
             // It's not important that the date lies in a certain week, but that the week belongs to the
             // current year and that the week day is preserved.
             if (date.Month == 1)
-                date = date.AddDays(7);
+                date = date.PlusDays(7);
             else if (date.Month >= 12)
-                date = date.AddDays(-7);
+                date = date.PlusDays(-7);
 
             // Determine our current week number
-            var currWeekNo = Calendar.GetIso8601WeekOfYear(date, pattern.FirstDayOfWeek);
+            var currWeekNo = weekYearRule.GetWeekOfWeekYear(date.Date);
 
             // Move ahead to the correct week of the year
-            date = date.AddDays((weekNo - currWeekNo) * 7);
+            date = date.PlusDays((weekNo - currWeekNo) * 7);
 
             // Ignore the week if it doesn't belong to the current year.
-            if (Calendar.GetIso8601YearOfWeek(date, pattern.FirstDayOfWeek) != t.Year)
+            if (weekYearRule.GetWeekYear(date.Date) != t.Year)
                 continue;
 
             // Step backward single days until we're at the correct DayOfWeek
             date = GetFirstDayOfWeekDate(date, pattern.FirstDayOfWeek);
 
-            foreach (var d in Enumerable.Range(0, 7).Select(i => date.AddDays(i)))
-                yield return d;
+            foreach (var d in Enumerable.Range(0, 7).Select(i => date.PlusDays(i)))
+                yield return d.InZoneLeniently(t.Zone);
         }
     }
 
-    private static CalDateTime GetFirstDayOfWeekDate(CalDateTime date, DayOfWeek firstDayOfWeek)
-        => date.AddDays(-((int) date.DayOfWeek + 7 - (int) firstDayOfWeek) % 7);
+    private static LocalDateTime GetFirstDayOfWeekDate(LocalDateTime date, DayOfWeek firstDayOfWeek)
+    {
+        var first = firstDayOfWeek.ToIsoDayOfWeek();
+        if (date.DayOfWeek == first)
+        {
+            return date;
+        }
+
+        return date.Previous(first);
+    }
 
     /// <summary>
     /// Normalize the BYWEEKNO values to be positive integers.
     /// </summary>
     private static List<int> GetByWeekNoForYearNormalized(RecurrencePattern pattern, int year)
     {
-        var weeksInYear = new Lazy<int>(() => Calendar.GetIso8601WeeksInYear(year, pattern.FirstDayOfWeek));
+        var weeksInYear = new Lazy<int>(() => GetWeekYearRule(pattern).GetWeeksInWeekYear(year));
         return pattern.ByWeekNo
             .Select(weekNo => weekNo >= 0 ? weekNo : weeksInYear.Value + weekNo + 1)
             .OrderBy(x => x)
@@ -503,7 +522,7 @@ private static List<int> GetByWeekNoForYearNormalized(RecurrencePattern pattern,
     /// Expanded dates produced for a given input are constrained to the same calendar year as the input date;
     /// out-of-range <c>BYYEARDAY</c> values (e.g. +-366 in non-leap years) are ignored.
     /// </returns>
-    private static IEnumerable<CalDateTime> GetYearDayVariants(IEnumerable<CalDateTime> dates, RecurrencePattern pattern, bool? expand, ref ExpandContext expandContext)
+    private static IEnumerable<ZonedDateTime> GetYearDayVariants(IEnumerable<ZonedDateTime> dates, RecurrencePattern pattern, bool? expand, ref ExpandContext expandContext)
     {
         if (expand is null || pattern.ByYearDay.Count == 0)
             return dates;
@@ -518,36 +537,37 @@ private static IEnumerable<CalDateTime> GetYearDayVariants(IEnumerable<CalDateTi
         return GetYearDayVariantsLimited(dates, pattern);
     }
 
-    private static IEnumerable<CalDateTime> GetYearDayVariantsExpanded(IEnumerable<CalDateTime> dates, RecurrencePattern pattern)
+    private static IEnumerable<ZonedDateTime> GetYearDayVariantsExpanded(IEnumerable<ZonedDateTime> dates, RecurrencePattern pattern)
     {
         foreach (var date in dates)
         {
-            var date1 = date;
-            var yearDayDates = new SortedSet<CalDateTime>(
+            var date1 = date.LocalDateTime;
+            var yearDayDates = new SortedSet<LocalDateTime>(
                 pattern.ByYearDay.Select(yearDay => yearDay > 0
-                ? date1.AddDays(-date1.DayOfYear + yearDay)
-                : date1.AddDays(-date1.DayOfYear + 1).AddYears(1).AddDays(yearDay))
+                ? date1.PlusDays(-date1.DayOfYear + yearDay)
+                : date1.PlusDays(-date1.DayOfYear + 1).PlusYears(1).PlusDays(yearDay))
                 // Ignore the BY values that don't fit into the current year (i.e. +-366 in non-leap-years).
                 .Where(d => d.Year == date1.Year));
 
             foreach (var d in yearDayDates)
-                yield return d;
+                yield return d.InZoneLeniently(date.Zone);
         }
     }
 
-    private static IEnumerable<CalDateTime> GetYearDayVariantsLimited(IEnumerable<CalDateTime> dates, RecurrencePattern pattern)
+    private static IEnumerable<ZonedDateTime> GetYearDayVariantsLimited(IEnumerable<ZonedDateTime> dates, RecurrencePattern pattern)
     {
-        foreach (var date in dates)
+        foreach (var zonedDate in dates)
         {
+            var date = zonedDate.LocalDateTime;
             var candidates =
                 from yearDay in pattern.ByYearDay
                 let newDate = yearDay > 0
-                    ? date.AddDays(-date.DayOfYear + yearDay)
-                    : date.AddDays(-date.DayOfYear + 1).AddYears(1).AddDays(yearDay)
+                    ? date.PlusDays(-date.DayOfYear + yearDay)
+                    : date.PlusDays(-date.DayOfYear + 1).PlusYears(1).PlusDays(yearDay)
                 select newDate;
 
             if (candidates.Contains(date))
-                yield return date;
+                yield return date.InZoneLeniently(zonedDate.Zone);
         }
     }
 
@@ -556,7 +576,7 @@ from yearDay in pattern.ByYearDay
     /// If no BYMONTHDAY rules are specified, the date list is returned unmodified.
     /// </summary>
     /// <returns>The modified list of dates after applying the BYMONTHDAY rules.</returns>
-    private static IEnumerable<CalDateTime> GetMonthDayVariants(IEnumerable<CalDateTime> dates, RecurrencePattern pattern, bool? expand, ref ExpandContext expandContext)
+    private static IEnumerable<ZonedDateTime> GetMonthDayVariants(IEnumerable<ZonedDateTime> dates, RecurrencePattern pattern, bool? expand, ref ExpandContext expandContext)
     {
         if (expand == null || pattern.ByMonthDay.Count == 0)
             return dates;
@@ -571,13 +591,13 @@ private static IEnumerable<CalDateTime> GetMonthDayVariants(IEnumerable<CalDateT
         return GetMonthDayVariantsLimited(dates, pattern);
     }
 
-    private static IEnumerable<CalDateTime> GetMonthDayVariantsLimited(IEnumerable<CalDateTime> dates, RecurrencePattern pattern)
+    private static IEnumerable<ZonedDateTime> GetMonthDayVariantsLimited(IEnumerable<ZonedDateTime> dates, RecurrencePattern pattern)
     {
         // Helper that checks whether the given candidate matches any BYMONTHDAY entry
         // taking negative values into account (relative to the month's length).
-        static bool MatchesAnyMonthDay(CalDateTime candidate, IEnumerable<int> monthDays)
+        static bool MatchesAnyMonthDay(ZonedDateTime candidate, IEnumerable<int> monthDays)
         {
-            var daysInMonth = Calendar.GetDaysInMonth(candidate.Year, candidate.Month);
+            var daysInMonth = CalendarSystem.Iso.GetDaysInMonth(candidate.Year, candidate.Month);
             foreach (var monthDay in monthDays)
             {
                 var byMonthDay = monthDay > 0 ? monthDay : (daysInMonth + monthDay + 1);
@@ -598,19 +618,20 @@ static bool MatchesAnyMonthDay(CalDateTime candidate, IEnumerable<int> monthDays
         }
     }
 
-    private static IEnumerable<CalDateTime> GetMonthDayVariantsExpanded(IEnumerable<CalDateTime> dates, RecurrencePattern pattern)
+    private static IEnumerable<ZonedDateTime> GetMonthDayVariantsExpanded(IEnumerable<ZonedDateTime> dates, RecurrencePattern pattern)
     {
-        foreach (var date in dates)
+        foreach (var zonedDate in dates)
         {
-            var monthDayDates = new SortedSet<CalDateTime>(
+            var date = zonedDate.LocalDateTime;
+            var monthDayDates = new SortedSet<LocalDateTime>(
                 from monthDay in pattern.ByMonthDay
-                let daysInMonth = Calendar.GetDaysInMonth(date.Year, date.Month)
+                let daysInMonth = CalendarSystem.Iso.GetDaysInMonth(date.Year, date.Month)
                 let monthDayAbs = (monthDay > 0) ? monthDay : (daysInMonth + monthDay + 1)
                 where (monthDayAbs > 0) && (monthDayAbs <= daysInMonth)
-                select date.AddDays(-date.Day + monthDayAbs));
+                select date.PlusDays(-date.Day + monthDayAbs));
 
             foreach (var d in monthDayDates)
-                yield return d;
+                yield return d.InZoneLeniently(zonedDate.Zone);
         }
     }
 
@@ -620,7 +641,7 @@ from monthDay in pattern.ByMonthDay
     /// </summary>
     /// <param name="dates">The list of dates to which BYDAY rules will be applied.</param>
     /// <returns>The modified list of dates after applying BYDAY rules, or the original list if no BYDAY rules are specified.</returns>
-    private static IEnumerable<CalDateTime> GetDayVariants(IEnumerable<CalDateTime> dates, RecurrencePattern pattern, bool? expand, ref ExpandContext expandContext)
+    private static IEnumerable<ZonedDateTime> GetDayVariants(IEnumerable<ZonedDateTime> dates, RecurrencePattern pattern, bool? expand, ref ExpandContext expandContext)
     {
         if (expand == null || pattern.ByDay.Count == 0)
             return dates;
@@ -636,7 +657,7 @@ private static IEnumerable<CalDateTime> GetDayVariants(IEnumerable<CalDateTime>
         return GetDayVariantsLimited(dates, pattern);
     }
 
-    private static IEnumerable<CalDateTime> GetDayVariantsLimited(IEnumerable<CalDateTime> dates, RecurrencePattern pattern)
+    private static IEnumerable<ZonedDateTime> GetDayVariantsLimited(IEnumerable<ZonedDateTime> dates, RecurrencePattern pattern)
         =>
             // If no offset is specified, simply test the day of week.
             // When an offset is present, use GetAbsWeekDays to compute the concrete
@@ -644,25 +665,27 @@ private static IEnumerable<CalDateTime> GetDayVariantsLimited(IEnumerable<CalDat
             dates.Where(date => pattern.ByDay.Any(weekDay =>
             {
                 if (weekDay.Offset is null)
-                    return weekDay.DayOfWeek.Equals(date.DayOfWeek);
+                    return weekDay.DayOfWeek.Equals(date.DayOfWeek.ToDayOfWeek());
 
                 // When limiting with an offset (e.g. "22MO" or "1MO"), compute the
                 // absolute dates for that WeekDay in the appropriate scope and
                 // check if the candidate matches one of them.
-                return GetAbsWeekDays(date, weekDay, pattern).Any(d => d.Equals(date));
+                return GetAbsWeekDays(date.LocalDateTime, weekDay, pattern)
+                    .Select(x => x.InZoneLeniently(date.Zone))
+                    .Any(d => d.Equals(date));
             }));
-    
-    private static IEnumerable<CalDateTime> GetDayVariantsExpanded(IEnumerable<CalDateTime> dates, RecurrencePattern pattern)
+
+    private static IEnumerable<ZonedDateTime> GetDayVariantsExpanded(IEnumerable<ZonedDateTime> dates, RecurrencePattern pattern)
     {
         foreach (var date in dates)
         {
-            var weekDayDates = new SortedSet<CalDateTime>(); // SortedSet uses CalDateTime.CompareTo
+            var weekDayDates = new SortedSet<LocalDateTime>();
             foreach (var day in pattern.ByDay)
-                foreach (var d in GetAbsWeekDays(date, day, pattern))
+                foreach (var d in GetAbsWeekDays(date.LocalDateTime, day, pattern))
                     weekDayDates.Add(d);
 
             foreach (var d in weekDayDates)
-                yield return d;
+                yield return d.InZoneLeniently(date.Zone);
         }
     }
 
@@ -673,7 +696,7 @@ private static IEnumerable<CalDateTime> GetDayVariantsExpanded(IEnumerable<CalDa
     /// <param name="date">The date to start the evaluation from.</param>
     /// <param name="weekDay">The week day to evaluate.</param>
     /// <returns>A list of applicable dates.</returns>
-    private static IEnumerable<CalDateTime> GetAbsWeekDays(CalDateTime date, WeekDay weekDay, RecurrencePattern pattern)
+    private static IEnumerable<LocalDateTime> GetAbsWeekDays(LocalDateTime date, WeekDay weekDay, RecurrencePattern pattern)
     {
         var dates = pattern switch
         {
@@ -687,77 +710,87 @@ private static IEnumerable<CalDateTime> GetAbsWeekDays(CalDateTime date, WeekDay
         return GetOffsetDates(dates, weekDay.Offset);
     }
 
-    private static IEnumerable<CalDateTime> GetAbsWeekDaysDaily(CalDateTime date, WeekDay weekDay)
-        => (date.DayOfWeek == weekDay.DayOfWeek) ? [date] : [];
+    private static IEnumerable<LocalDateTime> GetAbsWeekDaysDaily(LocalDateTime date, WeekDay weekDay)
+        => (date.DayOfWeek.ToDayOfWeek() == weekDay.DayOfWeek) ? [date] : [];
 
-    private static IEnumerable<CalDateTime> GetAbsWeekDaysYearly(CalDateTime date, WeekDay weekDay)
+    private static IEnumerable<LocalDateTime> GetAbsWeekDaysYearly(LocalDateTime date, WeekDay weekDay)
     {
         var year = date.Year;
         var daysInYear = DateTime.IsLeapYear(year) ? 366 : 365;
 
         // Go to Jan 1 and find first occurrence of target weekday
-        date = date.AddDays(-date.DayOfYear + 1);
-        var offset = ((int) weekDay.DayOfWeek - (int) date.DayOfWeek + 7) % 7;
-        date = date.AddDays(offset);
+        date = date.PlusDays(-date.DayOfYear + 1);
+        var targetDayOfWeek = weekDay.DayOfWeek.ToIsoDayOfWeek();
+        if (date.DayOfWeek != targetDayOfWeek)
+        {
+            date = date.Next(targetDayOfWeek);
+        }
 
         // Yield all occurrences (52 or 53 per year)
-        var occurrenceCount = (daysInYear - offset + 6) / 7;
+        var occurrenceCount = (daysInYear - date.Day + 7) / 7;
         for (var i = 0; i < occurrenceCount; i++)
         {
             yield return date;
-            date = date.AddDays(7);
+            date = date.PlusDays(7);
         }
     }
 
-    private static IEnumerable<CalDateTime> GetAbsWeekDaysMonthly(CalDateTime date, RecurrencePattern pattern, WeekDay weekDay)
+    private static IEnumerable<LocalDateTime> GetAbsWeekDaysMonthly(LocalDateTime date, RecurrencePattern pattern, WeekDay weekDay)
     {
-        var month = date.Month;
-        var year = date.Year;
-        var daysInMonth = Calendar.GetDaysInMonth(year, month);
+        var daysInMonth = date.Calendar.GetDaysInMonth(date.Year, date.Month);
 
         // Go to first day of month and find first occurrence of target weekday
-        date = date.AddDays(-date.Day + 1);
-        var offset = ((int) weekDay.DayOfWeek - (int) date.DayOfWeek + 7) % 7;
-        date = date.AddDays(offset);
+        date = date.PlusDays(-date.Day + 1);
+        var targetDayOfWeek = weekDay.DayOfWeek.ToIsoDayOfWeek();
+        if (date.DayOfWeek != targetDayOfWeek)
+        {
+            date = date.Next(targetDayOfWeek);
+        }
 
         // Pre-calculate occurrence count (4 or 5 occurrences per month)
-        var occurrenceCount = (daysInMonth - offset + 6) / 7;
+        var occurrenceCount = (daysInMonth - date.Day + 7) / 7;
+
+        var weekYearRule = GetWeekYearRule(pattern);
 
         var byWeekNoNormalized = pattern.ByWeekNo.Count > 0
-            ? GetByWeekNoForYearNormalized(pattern, Calendar.GetIso8601YearOfWeek(date, pattern.FirstDayOfWeek))
+            ? GetByWeekNoForYearNormalized(pattern, weekYearRule.GetWeekYear(date.Date))
             : null;
 
         for (var i = 0; i < occurrenceCount; i++)
         {
-            var matchesWeekNo = byWeekNoNormalized == null || byWeekNoNormalized.Contains(Calendar.GetIso8601WeekOfYear(date, pattern.FirstDayOfWeek));
+            var matchesWeekNo = byWeekNoNormalized == null || byWeekNoNormalized.Contains(weekYearRule.GetWeekOfWeekYear(date.Date));
             var matchesMonth = pattern.ByMonth.Count == 0 || pattern.ByMonth.Contains(date.Month);
 
             if (matchesWeekNo && matchesMonth)
             {
                 yield return date;
             }
-
-            date = date.AddDays(7);
+            date = date.PlusDays(7);
         }
     }
 
-    private static IEnumerable<CalDateTime> GetAbsWeekDaysWeekly(CalDateTime date, RecurrencePattern pattern, WeekDay weekDay)
+    private static IEnumerable<LocalDateTime> GetAbsWeekDaysWeekly(LocalDateTime date, RecurrencePattern pattern, WeekDay weekDay)
     {
-        var weekNo = Calendar.GetIso8601WeekOfYear(date, pattern.FirstDayOfWeek);
+        var weekYearRule = GetWeekYearRule(pattern);
+
+        var weekNo = weekYearRule.GetWeekOfWeekYear(date.Date);
 
         // Go to the first day of the week
         var weekDayOffset = GetWeekDayOffset(date, pattern.FirstDayOfWeek);
-        date = date.AddDays(-weekDayOffset);
+        date = date.PlusDays(-weekDayOffset);
 
         // Find first occurrence of target weekday
-        var offset = ((int) weekDay.DayOfWeek - (int) date.DayOfWeek + 7) % 7;
-        date = date.AddDays(offset);
+        var targetDayOfWeek = weekDay.DayOfWeek.ToIsoDayOfWeek();
+        if (date.DayOfWeek != targetDayOfWeek)
+        {
+            date = date.Next(targetDayOfWeek);
+        }
 
-        var currentWeekNo = Calendar.GetIso8601WeekOfYear(date, pattern.FirstDayOfWeek);
+        var currentWeekNo = weekYearRule.GetWeekOfWeekYear(date.Date);
         var nextWeekNo = currentWeekNo;
 
         var byWeekNoNormalized = pattern.ByWeekNo.Count > 0
-            ? GetByWeekNoForYearNormalized(pattern, Calendar.GetIso8601YearOfWeek(date, pattern.FirstDayOfWeek))
+            ? GetByWeekNoForYearNormalized(pattern, weekYearRule.GetWeekYear(date.Date))
             : null;
 
         // When we manage weekly recurring pattern, and we have boundary case:
@@ -773,16 +806,16 @@ private static IEnumerable<CalDateTime> GetAbsWeekDaysWeekly(CalDateTime date, R
                 yield return date;
             }
 
-            date = date.AddDays(7);
-            currentWeekNo = Calendar.GetIso8601WeekOfYear(date, pattern.FirstDayOfWeek);
+            date = date.PlusDays(7);
+            currentWeekNo = weekYearRule.GetWeekOfWeekYear(date.Date);
         }
     }
 
     /// <summary>
     /// Returns the days since the start of the week, 0 if the date is on the first day of the week.
     /// </summary>
-    private static int GetWeekDayOffset(CalDateTime date, DayOfWeek startOfWeek)
-        => date.DayOfWeek + ((date.DayOfWeek < startOfWeek) ? 7 : 0) - startOfWeek;
+    private static int GetWeekDayOffset(LocalDateTime date, DayOfWeek startOfWeek)
+        => date.DayOfWeek.ToDayOfWeek() + ((date.DayOfWeek.ToDayOfWeek() < startOfWeek) ? 7 : 0) - startOfWeek;
 
     /// <summary>
     /// Returns a single-element sublist containing the element of <paramref name="dates"/> at <paramref name="offset"/>. 
@@ -791,7 +824,7 @@ private static int GetWeekDayOffset(CalDateTime date, DayOfWeek startOfWeek)
     /// </summary>
     /// <param name="dates">The list from which to extract the element.</param>
     /// <param name="offset">The position of the element to extract.</param>
-    private static IEnumerable<CalDateTime> GetOffsetDates(IEnumerable<CalDateTime> dates, int? offset)
+    private static IEnumerable<LocalDateTime> GetOffsetDates(IEnumerable<LocalDateTime> dates, int? offset)
     {
         switch (offset)
         {
@@ -801,7 +834,7 @@ private static IEnumerable<CalDateTime> GetOffsetDates(IEnumerable<CalDateTime>
                 throw new EvaluationException("Encountered a day offset of 0 which is not allowed.");
             case < 0:
             {
-                var list = dates as IList<CalDateTime> ?? dates.ToList();
+                var list = dates as IList<LocalDateTime> ?? dates.ToList();
                 var index = list.Count + offset.Value;
                 return index >= 0 && index < list.Count
                     ? [list[index]]
@@ -820,7 +853,7 @@ private static IEnumerable<CalDateTime> GetOffsetDates(IEnumerable<CalDateTime>
     /// <param name="pattern"></param>
     /// <param name="expand"></param>
     /// <returns>The modified list of dates after applying the BYHOUR rules.</returns>
-    private static IEnumerable<CalDateTime> GetHourVariants(IEnumerable<CalDateTime> dates, RecurrencePattern pattern, bool? expand)
+    private static IEnumerable<ZonedDateTime> GetHourVariants(IEnumerable<ZonedDateTime> dates, RecurrencePattern pattern, bool? expand)
     {
         if (expand == null || pattern.ByHour.Count == 0)
             return dates;
@@ -828,7 +861,7 @@ private static IEnumerable<CalDateTime> GetHourVariants(IEnumerable<CalDateTime>
         if (expand.Value)
         {
             // Expand behavior
-            return dates.SelectMany(date => pattern.ByHour.Select(hour => date.AddHours(-date.Hour + hour)));
+            return ExpandTime(dates, pattern.ByHour, SetHour);
         }
 
         // Limit behavior
@@ -843,7 +876,10 @@ private static IEnumerable<CalDateTime> GetHourVariants(IEnumerable<CalDateTime>
     /// <param name="pattern"></param>
     /// <param name="expand"></param>
     /// <returns>The modified list of dates after applying the BYMINUTE rules.</returns>
-    private static IEnumerable<CalDateTime> GetMinuteVariants(IEnumerable<CalDateTime> dates, RecurrencePattern pattern, bool? expand)
+    private static IEnumerable<ZonedDateTime> GetMinuteVariants(
+        IEnumerable<ZonedDateTime> dates,
+        RecurrencePattern pattern,
+        bool? expand)
     {
         if (expand == null || pattern.ByMinute.Count == 0)
             return dates;
@@ -851,7 +887,7 @@ private static IEnumerable<CalDateTime> GetMinuteVariants(IEnumerable<CalDateTim
         if (expand.Value)
         {
             // Expand behavior
-            return dates.SelectMany(date => pattern.ByMinute.Select(minute => date.AddMinutes(-date.Minute + minute)));
+            return ExpandTime(dates, pattern.ByMinute, SetMinute);
         }
 
         // Limit behavior
@@ -866,7 +902,7 @@ private static IEnumerable<CalDateTime> GetMinuteVariants(IEnumerable<CalDateTim
     /// <param name="pattern"></param>
     /// <param name="expand"></param>
     /// <returns>The modified list of dates after applying the BYSECOND rules.</returns>
-    private static IEnumerable<CalDateTime> GetSecondVariants(IEnumerable<CalDateTime> dates, RecurrencePattern pattern, bool? expand)
+    private static IEnumerable<ZonedDateTime> GetSecondVariants(IEnumerable<ZonedDateTime> dates, RecurrencePattern pattern, bool? expand)
     {
         if (expand == null || pattern.BySecond.Count == 0)
             return dates;
@@ -874,30 +910,40 @@ private static IEnumerable<CalDateTime> GetSecondVariants(IEnumerable<CalDateTim
         if (expand.Value)
         {
             // Expand behavior
-            return dates.SelectMany(date => pattern.BySecond.Select(second => date.AddSeconds(-date.Second + second)));
+            return ExpandTime(dates, pattern.BySecond, SetSecond);
         }
 
         // Limit behavior
         return dates.Where(date => pattern.BySecond.Contains(date.Second));
     }
 
+    private static LocalTime SetHour(LocalTime time, int hour) => new(hour, time.Minute, time.Second);
+    private static LocalTime SetMinute(LocalTime time, int minute) => new(time.Hour, minute, time.Second);
+    private static LocalTime SetSecond(LocalTime time, int second) => new(time.Hour, time.Minute, second);
+
     /// <summary>
-    /// Creates a new period from the specified date/time,
-    /// where the <see cref="CalDateTime.HasTime"/> is taken into account.
-    /// when initializing the new period with a new <see cref="CalDateTime"/>.
+    /// Expands dates into the listed times using the given time adjusting function.
     /// </summary>
-    private static Period CreatePeriod(CalDateTime dateTime, CalDateTime referenceDate)
+    /// <param name="dates">Dates to expand</param>
+    /// <param name="byTimeUnit">The time values of a single unit (hour, minute, or second)</param>
+    /// <param name="timeAdjuster">Function to adjust the time with.</param>
+    /// <returns>Each date expanded by the time unit</returns>
+    private static IEnumerable<ZonedDateTime> ExpandTime(
+        IEnumerable<ZonedDateTime> dates,
+        List<int> byTimeUnit,
+        Func<LocalTime, int, LocalTime> timeAdjuster)
     {
-        // Turn each resulting date/time into an CalDateTime and associate it
-        // with the reference date.
-        var newDt = new CalDateTime(dateTime.Value, null, referenceDate.HasTime);
-        if (referenceDate.TzId != null) {
-            // Adjust nonexistent recurrence instances according to RFC 5545 3.3.5
-            newDt = newDt.ToTimeZone(referenceDate.TzId);
-        }
+        // This is run multiple times for each date, so avoid LINQ and use
+        // only static functions to avoid allocations.
 
-        // Create a period from the new date/time.
-        return new Period(newDt);
+        foreach (var date in dates)
+        {
+            foreach (var timeUnit in byTimeUnit)
+            {
+                var localTime = date.Date + timeAdjuster(date.TimeOfDay, timeUnit);
+                yield return localTime.InZoneRelativeTo(date);
+            }
+        }
     }
 
     /// <summary>
@@ -907,23 +953,27 @@ private static Period CreatePeriod(CalDateTime dateTime, CalDateTime referenceDa
     /// <param name="periodStart">Start (incl.) of the period occurrences are generated for.</param>
     /// <param name="options"></param>
     /// <returns></returns>
-    public override IEnumerable<Period> Evaluate(CalDateTime referenceDate, CalDateTime? periodStart, EvaluationOptions? options)
+    public override IEnumerable<EvaluationPeriod> Evaluate(CalDateTime referenceDate, DateTimeZone timeZone, Instant? periodStart, EvaluationOptions? options)
     {
         if (Pattern.Frequency < FrequencyType.Daily && !referenceDate.HasTime)
         {
             // This case is not defined by RFC 5545. We handle it by evaluating the rule
             // as if referenceDate had a time (i.e. set to midnight).
-            referenceDate = new CalDateTime(referenceDate.Date, new TimeOnly(), referenceDate.TzId);
+            referenceDate = new CalDateTime(referenceDate.Date, new LocalTime(), referenceDate.TzId);
         }
 
         // Create a recurrence pattern suitable for use during evaluation.
         var pattern = ProcessRecurrencePattern(referenceDate);
 
-        var periodQuery = GetDates(referenceDate, periodStart, pattern, options)
-            .Select(dt => CreatePeriod(dt, referenceDate));
+        var periodQuery = GetDates(referenceDate, timeZone, periodStart, pattern, options)
+            .Select(dt => new EvaluationPeriod(dt));
 
         if (pattern.Until is not null)
-            periodQuery = periodQuery.TakeWhile(p => p.StartTime <= pattern.Until);
+        {
+            var until = pattern.Until.ToZonedDateTime(timeZone).ToInstant();
+
+            periodQuery = periodQuery.TakeWhile(p => p.Start.ToInstant() <= until);
+        }
 
         return periodQuery;
     }
diff --git a/Ical.Net/Evaluation/RecurrenceUtil.cs b/Ical.Net/Evaluation/RecurrenceUtil.cs
index 1e1068f97..c480a04d5 100644
--- a/Ical.Net/Evaluation/RecurrenceUtil.cs
+++ b/Ical.Net/Evaluation/RecurrenceUtil.cs
@@ -9,12 +9,18 @@
 using Ical.Net.CalendarComponents;
 using Ical.Net.DataTypes;
 using Ical.Net.Utility;
+using NodaTime;
 
 namespace Ical.Net.Evaluation;
 
 internal static class RecurrenceUtil
 {
-    public static IEnumerable<Occurrence> GetOccurrences(IRecurrable recurrable, CalDateTime? periodStart, EvaluationOptions? options = null)
+    public static IEnumerable<Occurrence> GetOccurrences(IRecurrable recurrable, ZonedDateTime periodStart, EvaluationOptions? options = null)
+    {
+        return GetOccurrences(recurrable, periodStart.Zone, periodStart.ToInstant(), options);
+    }
+
+    public static IEnumerable<Occurrence> GetOccurrences(IRecurrable recurrable, DateTimeZone timeZone, Instant? periodStart, EvaluationOptions? options = null)
     {
         var evaluator = recurrable.Evaluator;
         if (evaluator == null || recurrable.Start == null)
@@ -24,19 +30,18 @@ public static IEnumerable<Occurrence> GetOccurrences(IRecurrable recurrable, Cal
 
         var start = recurrable.Start;
 
-        var periods = evaluator.Evaluate(start, periodStart, options);
+        var periods = evaluator.Evaluate(start, timeZone, periodStart, options);
         if (periodStart != null)
         {
             periods =
                 from p in periods
-                let effectiveEndTime = p.EffectiveEndTime
                 where
-                    p.StartTime.GreaterThanOrEqual(periodStart)
-                    || ((effectiveEndTime != null) && effectiveEndTime.GreaterThan(periodStart))
+                    p.Start.ToInstant() >= periodStart
+                    || (p.End != null && p.End.Value.ToInstant() > periodStart.Value)
                 select p;
         }
 
-        return periods.Select(p => new Occurrence(recurrable, p));
+        return periods.Select(p => new Occurrence(recurrable, p.Start, p.End ?? p.Start));
     }
 
     public static bool?[] GetExpandBehaviorList(RecurrencePattern p)
diff --git a/Ical.Net/Evaluation/RecurringEvaluator.cs b/Ical.Net/Evaluation/RecurringEvaluator.cs
index b9807842e..d26b46500 100644
--- a/Ical.Net/Evaluation/RecurringEvaluator.cs
+++ b/Ical.Net/Evaluation/RecurringEvaluator.cs
@@ -9,6 +9,7 @@
 using Ical.Net.CalendarComponents;
 using Ical.Net.DataTypes;
 using Ical.Net.Utility;
+using NodaTime;
 
 namespace Ical.Net.Evaluation;
 
@@ -16,8 +17,6 @@ public abstract class RecurringEvaluator : Evaluator
 {
     protected IRecurrable Recurrable { get; set; }
 
-    protected abstract Duration? DefaultDuration { get; }
-
     protected RecurringEvaluator(IRecurrable obj)
     {
         Recurrable = obj;
@@ -29,18 +28,15 @@ protected RecurringEvaluator(IRecurrable obj)
     /// <param name="referenceDate"></param>
     /// <param name="periodStart">The beginning date of the range to evaluate.</param>
     /// <param name="options"></param>
-    protected IEnumerable<Period> EvaluateRRule(CalDateTime referenceDate, CalDateTime? periodStart, EvaluationOptions? options)
+    protected IEnumerable<EvaluationPeriod> EvaluateRRule(CalDateTime referenceDate, DateTimeZone timeZone, Instant? periodStart, EvaluationOptions? options)
     {
         if (!Recurrable.RecurrenceRules.Any())
             return [];
 
-        var d = this.DefaultDuration;
-        var effPeriodStart = (d != null) ? periodStart?.AddLeniently(-d.Value) : periodStart;
-
         var periodsQueries = Recurrable.RecurrenceRules.Select(rule =>
         {
             var ruleEvaluator = new RecurrencePatternEvaluator(rule);
-            return ruleEvaluator.Evaluate(referenceDate, effPeriodStart, options);
+            return ruleEvaluator.Evaluate(referenceDate, timeZone, periodStart, options);
         })
             // Enumerate the outer sequence (not the inner sequences of periods themselves) now to ensure
             // the initialization code is run, including validation and error handling.
@@ -50,10 +46,19 @@ protected IEnumerable<Period> EvaluateRRule(CalDateTime referenceDate, CalDateTi
         return periodsQueries.OrderedMergeMany();
     }
 
+    protected abstract EvaluationPeriod EvaluateRDate(DataTypes.Period rdate, DateTimeZone referenceTimeZone);
+
     /// <summary> Evaluates the RDate component. </summary>
-    protected IEnumerable<Period> EvaluateRDate()
-        => new SortedSet<Period>(Recurrable.RecurrenceDates
-                .GetAllPeriodsByKind(PeriodKind.Period, PeriodKind.DateOnly, PeriodKind.DateTime));
+    protected SortedSet<EvaluationPeriod> EvaluateRDate(DateTimeZone referenceTimeZone)
+    {
+        var result = Recurrable.RecurrenceDates
+            .GetAllPeriodsByKind(PeriodKind.Period, PeriodKind.DateOnly, PeriodKind.DateTime)
+            .Select(x => EvaluateRDate(x, referenceTimeZone))
+            // Convert overflow exceptions to expected ones.
+            .HandleEvaluationExceptions();
+
+        return new SortedSet<EvaluationPeriod>(result);
+    }
 
     /// <summary>
     /// Evaluates the ExRule component.
@@ -61,19 +66,19 @@ protected IEnumerable<Period> EvaluateRDate()
     /// <param name="referenceDate"></param>
     /// <param name="options"></param>
     [Obsolete("EXRULE is marked as deprecated in RFC 5545 and will be removed in a future version")]
-    private IEnumerable<Period> EvaluateExRule(CalDateTime referenceDate, EvaluationOptions? options)
+    private IEnumerable<EvaluationPeriod> EvaluateExRule(CalDateTime referenceDate, DateTimeZone timeZone, EvaluationOptions? options)
     {
         if (!Recurrable.ExceptionRules.Any())
             return [];
 
-        // We don't apply periodStart here, because calculating it would be quire complex, because
+        // We don't apply periodStart here. Calculating it would be complex because
         // RDATE's may have arbitrary durations.
-        CalDateTime? effPeriodStart = null;
+        Instant? effPeriodStart = null;
 
         var exRuleEvaluatorQueries = Recurrable.ExceptionRules.Select(exRule =>
         {
             var exRuleEvaluator = new RecurrencePatternEvaluator(exRule);
-            return exRuleEvaluator.Evaluate(referenceDate, effPeriodStart, options);
+            return exRuleEvaluator.Evaluate(referenceDate, timeZone, effPeriodStart, options);
         })
             // Enumerate the outer sequence (not the inner sequences of periods themselves) now to ensure
             // the initialization code is run, including validation and error handling.
@@ -87,21 +92,32 @@ private IEnumerable<Period> EvaluateExRule(CalDateTime referenceDate, Evaluation
     /// Evaluates the ExDate component.
     /// </summary>
     /// <param name="periodKinds">The period kinds to be returned. Used as a filter.</param>
-    private IEnumerable<Period> EvaluateExDate(params PeriodKind[] periodKinds)
-        => new SortedSet<Period>(Recurrable.ExceptionDates.GetAllPeriodsByKind(periodKinds));
+    private IEnumerable<DataTypes.Period> EvaluateExDate(params PeriodKind[] periodKinds)
+        => Recurrable.ExceptionDates.GetAllPeriodsByKind(periodKinds);
+
+    /// <summary>
+    /// Determines the end of an occurrence given the start.
+    /// This usually depends on the original reccurring source.
+    /// </summary>
+    /// <param name="start">Start of an occurrence</param>
+    /// <returns>End of an occurrence</returns>
+    protected abstract ZonedDateTime GetEnd(ZonedDateTime start);
 
-    public override IEnumerable<Period> Evaluate(CalDateTime referenceDate, CalDateTime? periodStart, EvaluationOptions? options)
+    public override IEnumerable<EvaluationPeriod> Evaluate(CalDateTime referenceDate, DateTimeZone timeZone, Instant? periodStart, EvaluationOptions? options)
     {
-        IEnumerable<Period> rruleOccurrences;
+        IEnumerable<EvaluationPeriod> rruleOccurrences;
+
+        // Evaluate recurrence in the reference zone
+        var zonedReference = referenceDate.AsZonedOrDefault(timeZone);
 
         // Only add referenceDate if there are no RecurrenceRules defined. This is in line
         // with RFC 5545 which requires DTSTART to match any RRULE. If it doesn't, the behaviour
         // is undefined. It seems to be good practice not to return the referenceDate in this case.
         rruleOccurrences = !Recurrable.RecurrenceRules.Any()
-            ? [new Period(referenceDate)]
-            : EvaluateRRule(referenceDate, periodStart, options);
+            ? [new EvaluationPeriod(zonedReference)]
+            : EvaluateRRule(referenceDate, zonedReference.Zone, periodStart, options);
 
-        var rdateOccurrences = EvaluateRDate();
+        var rdateOccurrences = EvaluateRDate(zonedReference.Zone);
 
         var periods =
             rruleOccurrences
@@ -109,28 +125,28 @@ public override IEnumerable<Period> Evaluate(CalDateTime referenceDate, CalDateT
             .OrderedDistinct();
 
         // Apply the default duration, if any.
-        var d = this.DefaultDuration;
-        if (d != null)
-            periods = periods.Select(p => (p.EffectiveDuration != null) ? p : new Period(p.StartTime, d.Value));
+        periods = periods.Select(p => (p.End != null) ? p : new EvaluationPeriod(p.Start, GetEnd(p.Start)));
 
         // Filter by periodStart
         if (periodStart is not null)
         {
             // Include occurrences that start before periodStart, but end after periodStart.
-            periods = periods.Where(p => (p.StartTime >= periodStart) || (p.EffectiveEndTime > periodStart));
+            periods = periods.Where(p => (p.Start.ToInstant() >= periodStart.Value)
+                || (p.End?.ToInstant() > periodStart.Value));
         }
 
-        var exRuleExclusions = EvaluateExRule(referenceDate, options);
+        var exRuleExclusions = EvaluateExRule(referenceDate, zonedReference.Zone, options);
 
         // EXDATEs could contain date-only entries while DTSTART is date-time. This case isn't clearly defined
         // by the RFC, but it seems to be used in the wild (see https://github.com/ical-org/ical.net/issues/829).
         // Different systems handle this differently, e.g. Outlook excludes any occurrences where the date portion
         // matches an date-only EXDATE, while Google Calendar ignores such EXDATEs completely, if DTSTART is date-time.
         // In Ical.Net we follow the Outlook approach, which requires us to handle date-only EXDATEs separately.
-        var exDateExclusionsDateOnly = new HashSet<DateOnly>(EvaluateExDate(PeriodKind.DateOnly)
-            .Select(x => x.StartTime.Date));
+        var exDateExclusionsDateOnly = new HashSet<LocalDate>(EvaluateExDate(PeriodKind.DateOnly)
+            .Select(x => x.StartTime.ToLocalDateTime().Date));
 
-        var exDateExclusionsDateTime = EvaluateExDate(PeriodKind.DateTime);
+        var exDateExclusionsDateTime = new SortedSet<EvaluationPeriod>(EvaluateExDate(PeriodKind.DateTime)
+            .Select(x => new EvaluationPeriod(x.StartTime.ToZonedDateTime(zonedReference.Zone))));
 
         // Exclude occurrences according to EXRULEs and EXDATEs.
         periods = periods
@@ -144,7 +160,10 @@ public override IEnumerable<Period> Evaluate(CalDateTime referenceDate, CalDateT
             // The order of dates in the EXDATEs doesn't necessarily match the order of dates returned by RDATEs
             // due to RDATEs could have different time zones. We therefore use a regular `.Where()` to look up
             // the EXDATEs in the HashSet rather than using `.OrderedExclude()`, which would require correct ordering.
-            .Where(dt => !exDateExclusionsDateOnly.Contains(dt.StartTime.Date));
+            .Where(dt => !exDateExclusionsDateOnly.Contains(dt.Start.Date));
+
+        // Convert results to the requested time zone
+        periods = periods.Select(x => x.WithZone(timeZone));
 
         periods = periods
             // Convert overflow exceptions to expected ones.
diff --git a/Ical.Net/Evaluation/TimeZoneInfoEvaluator.cs b/Ical.Net/Evaluation/TimeZoneInfoEvaluator.cs
index a52a6b401..197dcf30e 100644
--- a/Ical.Net/Evaluation/TimeZoneInfoEvaluator.cs
+++ b/Ical.Net/Evaluation/TimeZoneInfoEvaluator.cs
@@ -4,7 +4,6 @@
 //
 
 using System;
-using System.Collections.Generic;
 using Ical.Net.CalendarComponents;
 using Ical.Net.DataTypes;
 
@@ -18,7 +17,9 @@ protected VTimeZoneInfo TimeZoneInfo
         set => Recurrable = value;
     }
 
-    protected override Duration? DefaultDuration => null;
+    protected override NodaTime.ZonedDateTime GetEnd(NodaTime.ZonedDateTime start) => start;
+    protected override EvaluationPeriod EvaluateRDate(Period rdate, NodaTime.DateTimeZone referenceTimeZone)
+        => throw new NotImplementedException();
 
     public TimeZoneInfoEvaluator(IRecurrable tzi) : base(tzi) { }
 }
diff --git a/Ical.Net/Evaluation/TodoEvaluator.cs b/Ical.Net/Evaluation/TodoEvaluator.cs
index 25f4fe5ca..9cfbde9f1 100644
--- a/Ical.Net/Evaluation/TodoEvaluator.cs
+++ b/Ical.Net/Evaluation/TodoEvaluator.cs
@@ -8,6 +8,7 @@
 using System.Linq;
 using Ical.Net.CalendarComponents;
 using Ical.Net.DataTypes;
+using NodaTime;
 
 namespace Ical.Net.Evaluation;
 
@@ -15,32 +16,33 @@ public class TodoEvaluator : RecurringEvaluator
 {
     protected Todo Todo => Recurrable as Todo ?? throw new InvalidOperationException();
 
-    protected override Duration? DefaultDuration => Todo.EffectiveDuration;
-
     public TodoEvaluator(Todo todo) : base(todo) { }
 
-    internal IEnumerable<Period> EvaluateToPreviousOccurrence(CalDateTime completedDate, CalDateTime currDt, EvaluationOptions? options)
+    internal IEnumerable<EvaluationPeriod> EvaluateToPreviousOccurrence(ZonedDateTime completedDate, ZonedDateTime currDt, EvaluationOptions? options)
     {
         // Cannot evaluate a todos that have no start date
         if (Todo.Start == null)
             return [];
 
-        var beginningDate = completedDate.Copy();
+        var beginningDate = completedDate;
 
         foreach (var rrule in Todo.RecurrenceRules)
         {
             DetermineStartingRecurrence(rrule, ref beginningDate);
         }
 
-        DetermineStartingRecurrence(Todo.RecurrenceDates.GetAllPeriods(), ref beginningDate);
-        DetermineStartingRecurrence(Todo.RecurrenceDates.GetAllDates(), ref beginningDate);
+        DetermineStartingRecurrence(Todo.RecurrenceDates.GetAllPeriods()
+            .Select(x => new EvaluationPeriod(x.StartTime.ToZonedDateTime(completedDate.Zone), x.EndTime?.ToZonedDateTime(completedDate.Zone))), ref beginningDate);
+        DetermineStartingRecurrence(Todo.RecurrenceDates.GetAllDates()
+            .Select(x => x.ToZonedDateTime(completedDate.Zone)), ref beginningDate);
 
         foreach (var exrule in Todo.ExceptionRules)
         {
             DetermineStartingRecurrence(exrule, ref beginningDate);
         }
 
-        DetermineStartingRecurrence(Todo.ExceptionDates.GetAllDates(), ref beginningDate);
+        DetermineStartingRecurrence(Todo.ExceptionDates.GetAllDates()
+            .Select(x => x.ToZonedDateTime(completedDate.Zone)), ref beginningDate);
 
         if (Todo.Start == null)
         {
@@ -48,35 +50,35 @@ internal IEnumerable<Period> EvaluateToPreviousOccurrence(CalDateTime completedD
         }
 
         return Evaluate(Todo.Start, beginningDate, options)
-            .Where(p => p.StartTime <= currDt);
+            .Where(p => p.Start.ToInstant() <= currDt.ToInstant());
     }
 
-    private static void DetermineStartingRecurrence(IEnumerable<Period> rdate, ref CalDateTime referenceDateTime)
+    private static void DetermineStartingRecurrence(IEnumerable<EvaluationPeriod> rdate, ref ZonedDateTime referenceDateTime)
     {
         var dt2 = referenceDateTime;
-        foreach (var p in rdate.Where(p => p.StartTime.LessThan(dt2)))
+        foreach (var p in rdate.Where(p => p.Start.ToInstant() < dt2.ToInstant()))
         {
-            referenceDateTime = p.StartTime;
+            referenceDateTime = p.Start;
         }
     }
 
-    private static void DetermineStartingRecurrence(IEnumerable<CalDateTime> rdate, ref CalDateTime referenceDateTime)
+    private static void DetermineStartingRecurrence(IEnumerable<ZonedDateTime> rdate, ref ZonedDateTime referenceDateTime)
     {
         var dt2 = referenceDateTime;
-        foreach (var dt in rdate.Where(dt => dt.LessThan(dt2)))
+        foreach (var dt in rdate.Where(dt => dt.ToInstant() < dt2.ToInstant()))
         {
             referenceDateTime = dt;
         }
     }
 
-    private void DetermineStartingRecurrence(RecurrencePattern recur, ref CalDateTime referenceDateTime)
+    private void DetermineStartingRecurrence(RecurrencePattern recur, ref ZonedDateTime referenceDateTime)
     {
         if (Todo.Start is null) return;
 
         if (recur.Count.HasValue)
         {
             // Caller ensures that Start is not null
-            referenceDateTime = Todo.Start!.Copy();
+            referenceDateTime = Todo.Start!.AsZonedOrDefault(referenceDateTime.Zone);
         }
         else
         {
@@ -84,12 +86,73 @@ private void DetermineStartingRecurrence(RecurrencePattern recur, ref CalDateTim
         }
     }
 
-    public override IEnumerable<Period> Evaluate(CalDateTime referenceDate, CalDateTime? periodStart, EvaluationOptions? options)
+    protected override EvaluationPeriod EvaluateRDate(DataTypes.Period rdate, DateTimeZone referenceTimeZone)
+    {
+        var start = rdate.StartTime.AsZonedOrDefault(referenceTimeZone);
+
+        ZonedDateTime? end = null;
+        if (rdate.Duration is { } duration)
+        {
+            end = start.LocalDateTime
+                .Plus(duration.GetNominalPart())
+                .InZoneRelativeTo(start)
+                .Plus(duration.GetTimePart());
+        }
+        else if (rdate.EndTime is { } dtEnd)
+        {
+            var exactDuration = dtEnd.ToInstant() - rdate.StartTime.ToInstant();
+
+            if (exactDuration < NodaTime.Duration.Zero)
+            {
+                throw new InvalidOperationException("DtEnd is before DtStart");
+            }
+
+            end = start.Plus(exactDuration);
+        }
+        else
+        {
+            // Use event
+            end = GetEnd(start);
+        }
+
+        return new EvaluationPeriod(start, end);
+    }
+
+    protected override ZonedDateTime GetEnd(ZonedDateTime start)
+    {
+        var dtStart = Todo.DtStart;
+
+        if (Todo.Duration is { } duration)
+        {
+            if (dtStart is null)
+            {
+                throw new EvaluationException("DtStart must be set when a TODO has a duration.");
+            }
+
+            // Add nominal values (weeks & days) to local time
+            // and then add accurate time to zoned time.
+            return start.LocalDateTime
+                .Plus(duration.GetNominalPart())
+                .InZoneRelativeTo(start)
+                .Plus(duration.GetTimePart());
+        }
+
+        if (Todo.Due is { } due && dtStart is not null)
+        {
+            var exactDuration = due.ToInstant() - dtStart.ToInstant();
+            return start.Plus(exactDuration);
+        }
+
+        // No due date, just return start
+        return start;
+    }
+
+    public override IEnumerable<EvaluationPeriod> Evaluate(CalDateTime referenceDate, DateTimeZone timeZone, Instant? periodStart, EvaluationOptions? options)
     {
         // Items can only recur if a start date is specified
         if (Todo.Start == null)
             return [];
 
-        return base.Evaluate(referenceDate, periodStart, options);
+        return base.Evaluate(referenceDate, timeZone, periodStart, options);
     }
 }
diff --git a/Ical.Net/IGetFreeBusy.cs b/Ical.Net/IGetFreeBusy.cs
index bf542eab4..33a9a3c68 100644
--- a/Ical.Net/IGetFreeBusy.cs
+++ b/Ical.Net/IGetFreeBusy.cs
@@ -6,12 +6,13 @@
 using System.Collections.Generic;
 using Ical.Net.CalendarComponents;
 using Ical.Net.DataTypes;
+using NodaTime;
 
 namespace Ical.Net;
 
 public interface IGetFreeBusy
 {
-    FreeBusy? GetFreeBusy(FreeBusy freeBusyRequest);
-    FreeBusy? GetFreeBusy(CalDateTime fromInclusive, CalDateTime toExclusive);
-    FreeBusy? GetFreeBusy(Organizer organizer, IEnumerable<Attendee> contacts, CalDateTime fromInclusive, CalDateTime toExclusive);
+    FreeBusy? GetFreeBusy(DateTimeZone timeZone, FreeBusy freeBusyRequest);
+    FreeBusy? GetFreeBusy(DateTimeZone timeZone, CalDateTime fromInclusive, CalDateTime toExclusive);
+    FreeBusy? GetFreeBusy(DateTimeZone timeZone, Organizer organizer, IEnumerable<Attendee> contacts, CalDateTime fromInclusive, CalDateTime toExclusive);
 }
diff --git a/Ical.Net/IGetOccurrences.cs b/Ical.Net/IGetOccurrences.cs
index ca5db0b76..49b1ad48a 100644
--- a/Ical.Net/IGetOccurrences.cs
+++ b/Ical.Net/IGetOccurrences.cs
@@ -7,6 +7,7 @@
 using Ical.Net.CalendarComponents;
 using Ical.Net.DataTypes;
 using Ical.Net.Evaluation;
+using NodaTime;
 
 namespace Ical.Net;
 
@@ -27,8 +28,9 @@ public interface IGetOccurrences
     /// <para/>
     /// It is advisable to limit indefinite sequences by applying the <see cref="CollectionExtensions.TakeWhileBefore(IEnumerable{Occurrence},CalDateTime)"/> extension method,
     /// or LINQ methods like <c>.TakeWhile()</c>
-    /// </remarks>  
-    IEnumerable<Occurrence> GetOccurrences(CalDateTime? startTime = null, EvaluationOptions? options = null);
+    /// </remarks>
+    IEnumerable<Occurrence> GetOccurrences(ZonedDateTime startTime, EvaluationOptions? options = null);
+    IEnumerable<Occurrence> GetOccurrences(DateTimeZone timeZone, Instant? startTime = null, EvaluationOptions? options = null);
 }
 
 public interface IGetOccurrencesTyped : IGetOccurrences
@@ -49,5 +51,6 @@ public interface IGetOccurrencesTyped : IGetOccurrences
     /// It is advisable to limit indefinite sequences by applying the <see cref="CollectionExtensions.TakeWhileBefore(IEnumerable{Occurrence},CalDateTime)"/> extension method,
     /// or LINQ methods like <c>.TakeWhile()</c>
     /// </remarks>  
-    IEnumerable<Occurrence> GetOccurrences<T>(CalDateTime? startTime = null, EvaluationOptions? options = null) where T : IRecurringComponent;
+    IEnumerable<Occurrence> GetOccurrences<T>(ZonedDateTime startTime, EvaluationOptions? options = null) where T : IRecurringComponent;
+    IEnumerable<Occurrence> GetOccurrences<T>(DateTimeZone timeZone, Instant? startTime = null, EvaluationOptions? options = null) where T : IRecurringComponent;
 }
diff --git a/Ical.Net/Ical.Net.csproj b/Ical.Net/Ical.Net.csproj
index 2d4e5b641..447d27e97 100644
--- a/Ical.Net/Ical.Net.csproj
+++ b/Ical.Net/Ical.Net.csproj
@@ -10,8 +10,8 @@
         <PackageReference Include="NodaTime" Version="3.2.2" />
         <PackageReference Include="Microsoft.CodeAnalysis.NetAnalyzers" Version="9.0.0" PrivateAssets="all" />
     </ItemGroup>
-    <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0' OR '$(TargetFramework)' == 'netstandard2.1'">
-        <PackageReference Include="Portable.System.DateTimeOnly" Version="9.0.0" />
+    <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
+        <PackageReference Include="Microsoft.Bcl.HashCode" Version="6.0.0" />
     </ItemGroup>
     <ItemGroup>
         <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleToAttribute">
diff --git a/Ical.Net/NodaTimeExtensions.cs b/Ical.Net/NodaTimeExtensions.cs
new file mode 100644
index 000000000..7765486d8
--- /dev/null
+++ b/Ical.Net/NodaTimeExtensions.cs
@@ -0,0 +1,48 @@
+//
+// Copyright ical.net project maintainers and contributors.
+// Licensed under the MIT license.
+//
+
+using NodaTime;
+using NodaTime.TimeZones;
+
+namespace Ical.Net;
+internal static class NodaTimeExtensions
+{
+    /// <summary>
+    /// Returns a ZonedDateTime that is matches the time zone and
+    /// offset of the start value, or shifts forward if the local
+    /// time does not exist.
+    /// </summary>
+    /// <param name="value"></param>
+    /// <param name="start"></param>
+    /// <returns></returns>
+    internal static ZonedDateTime InZoneRelativeTo(this LocalDateTime value, ZonedDateTime start)
+    {
+        var map = start.Zone.MapLocal(value);
+
+        if (map.Count == 1)
+        {
+            return map.Single();
+        }
+        else if (map.Count == 2)
+        {
+            // Only map forward in time
+            var last = map.Last();
+            if (last.Offset == start.Offset)
+            {
+                return last;
+            }
+            else
+            {
+                return map.First();
+            }
+        }
+        else
+        {
+            // Invalid local time, shift forward
+            return Resolvers.ReturnForwardShifted
+                .Invoke(map.LocalDateTime, map.Zone, map.EarlyInterval, map.LateInterval);
+        }
+    }
+}
diff --git a/Ical.Net/Serialization/DataTypes/DateTimeSerializer.cs b/Ical.Net/Serialization/DataTypes/DateTimeSerializer.cs
index 67fbc2e64..07e16bd03 100644
--- a/Ical.Net/Serialization/DataTypes/DateTimeSerializer.cs
+++ b/Ical.Net/Serialization/DataTypes/DateTimeSerializer.cs
@@ -11,6 +11,7 @@
 using System.Text.RegularExpressions;
 using Ical.Net.DataTypes;
 using Ical.Net.Utility;
+using NodaTime;
 
 namespace Ical.Net.Serialization.DataTypes;
 
@@ -87,18 +88,25 @@ public DateTimeSerializer(SerializationContext ctx) : base(ctx) { }
             return null;
         }
 
-        var datePart = new DateOnly(); // Initialize. At this point, we know that the date part is present
-        TimeOnly? timePart = null;
+        var datePart = new LocalDate(); // Initialize. At this point, we know that the date part is present
+        LocalTime? timePart = null;
 
         if (match.Groups[1].Success)
         {
-            datePart = new DateOnly(Convert.ToInt32(match.Groups[2].Value, CultureInfo.InvariantCulture),
+            datePart = new LocalDate(Convert.ToInt32(match.Groups[2].Value, CultureInfo.InvariantCulture),
                 Convert.ToInt32(match.Groups[3].Value, CultureInfo.InvariantCulture),
                 Convert.ToInt32(match.Groups[4].Value, CultureInfo.InvariantCulture));
+
+            // NodaTime supports year values <1 (BCE). Make sure these
+            // years are considered invalid.
+            if (datePart.Year < 1)
+            {
+                throw new ArgumentOutOfRangeException(nameof(tr), "Year must be a positive value");
+            }
         }
         if (match.Groups.Count >= 6 && match.Groups[5].Success)
         {
-            timePart = new TimeOnly(Convert.ToInt32(match.Groups[6].Value, CultureInfo.InvariantCulture),
+            timePart = new LocalTime(Convert.ToInt32(match.Groups[6].Value, CultureInfo.InvariantCulture),
                 Convert.ToInt32(match.Groups[7].Value, CultureInfo.InvariantCulture),
                 Convert.ToInt32(match.Groups[8].Value, CultureInfo.InvariantCulture));
         }
diff --git a/Ical.Net/Serialization/DataTypes/PeriodListSerializer.cs b/Ical.Net/Serialization/DataTypes/PeriodListSerializer.cs
index afb6e153b..5ecfe6a70 100644
--- a/Ical.Net/Serialization/DataTypes/PeriodListSerializer.cs
+++ b/Ical.Net/Serialization/DataTypes/PeriodListSerializer.cs
@@ -56,7 +56,7 @@ public PeriodListSerializer(SerializationContext ctx) : base(ctx) { }
 
         foreach (var p in periodList)
         {
-            parts.Add(p.EffectiveDuration != null
+            parts.Add(p.HasEndOrDuration
                 ? periodSerializer.SerializeToString(p)
                 : dtSerializer.SerializeToString(p.StartTime));
         }
diff --git a/Ical.Net/Utility/CollectionHelpers.cs b/Ical.Net/Utility/CollectionHelpers.cs
index 21dc115f5..66fc369a6 100644
--- a/Ical.Net/Utility/CollectionHelpers.cs
+++ b/Ical.Net/Utility/CollectionHelpers.cs
@@ -14,34 +14,19 @@ internal static class CollectionHelpers
     /// <summary> Commutative, stable, order-independent hashing for collections of collections. </summary>
     public static int GetHashCode<T>(IEnumerable<T>? collection)
     {
-        unchecked
+        if (collection == null)
         {
-            if (collection == null)
-            {
-                return 0;
-            }
-
-            return collection
-                .Where(e => e != null)
-                .Aggregate(0, (current, element) => current + element?.GetHashCode() ?? 0);
+            return 0;
         }
-    }
 
-    /// <summary> Commutative, stable, order-independent hashing for collections of collections. </summary>
-    public static int GetHashCodeForNestedCollection<T>(IEnumerable<IEnumerable<T>>? nestedCollection)
-    {
-        unchecked
-        {
-            if (nestedCollection == null)
-            {
-                return 0;
-            }
+        var hashCode = new HashCode();
 
-            return nestedCollection
-                .SelectMany(c => c)
-                .Where(e => e != null)
-                .Aggregate(0, (current, element) => current + element?.GetHashCode() ?? 0);
+        foreach (var item in collection)
+        {
+            hashCode.Add(item);
         }
+
+        return hashCode.ToHashCode();
     }
 
     public static bool Equals<T>(IEnumerable<T>? left, IEnumerable<T>? right, bool orderSignificant = false)
diff --git a/Ical.Net/Utility/DateUtil.cs b/Ical.Net/Utility/DateUtil.cs
index a2aa1564b..4c2c39bd7 100644
--- a/Ical.Net/Utility/DateUtil.cs
+++ b/Ical.Net/Utility/DateUtil.cs
@@ -11,31 +11,6 @@ namespace Ical.Net.Utility;
 
 internal static class DateUtil
 {
-    public static CalDateTime AsCalDateTime(this DateTime t)
-        => new CalDateTime(t);
-
-    public static CalDateTime AddWeeks(CalDateTime dt, int interval, DayOfWeek firstDayOfWeek)
-    {
-        dt = dt.AddDays(interval * 7);
-        while (dt.DayOfWeek != firstDayOfWeek)
-        {
-            dt = dt.AddDays(-1);
-        }
-
-        return dt;
-    }
-
-    public static CalDateTime FirstDayOfWeek(CalDateTime dt, DayOfWeek firstDayOfWeek, out int offset)
-    {
-        offset = 0;
-        while (dt.DayOfWeek != firstDayOfWeek)
-        {
-            dt = dt.AddDays(-1);
-            offset++;
-        }
-        return dt;
-    }
-
     /// <summary>
     /// Returns the NodaTime DateTimeZone for the given TZID according to the
     /// current time zone resolver set in TimeZoneResolvers.TimeZoneResolver.
@@ -45,67 +20,6 @@ public static CalDateTime FirstDayOfWeek(CalDateTime dt, DayOfWeek firstDayOfWee
     public static DateTimeZone GetZone(string tzId)
         => TimeZoneResolvers.TimeZoneResolver(tzId) ?? throw new ArgumentException($"Unrecognized time zone id {tzId}", nameof(tzId));
 
-    public static ZonedDateTime AddYears(ZonedDateTime zonedDateTime, int years)
-    {
-        var futureDate = zonedDateTime.Date.PlusYears(years);
-        var futureLocalDateTime = new LocalDateTime(futureDate.Year, futureDate.Month, futureDate.Day, zonedDateTime.Hour, zonedDateTime.Minute,
-            zonedDateTime.Second);
-        var zonedFutureDate = new ZonedDateTime(futureLocalDateTime, zonedDateTime.Zone, zonedDateTime.Offset);
-        return zonedFutureDate;
-    }
-
-    public static ZonedDateTime AddMonths(ZonedDateTime zonedDateTime, int months)
-    {
-        var futureDate = zonedDateTime.Date.PlusMonths(months);
-        var futureLocalDateTime = new LocalDateTime(futureDate.Year, futureDate.Month, futureDate.Day, zonedDateTime.Hour, zonedDateTime.Minute,
-            zonedDateTime.Second);
-        var zonedFutureDate = new ZonedDateTime(futureLocalDateTime, zonedDateTime.Zone, zonedDateTime.Offset);
-        return zonedFutureDate;
-    }
-
-    public static ZonedDateTime ToZonedDateTimeLeniently(DateTime dateTime, string tzId)
-    {
-        var zone = GetZone(tzId);
-        var localDt = LocalDateTime.FromDateTime(dateTime);
-
-        // RFC 5545 3.3.5
-        // If, based on the definition of the referenced time zone, the local
-        // time described occurs more than once(when changing from daylight
-        // to standard time), the DATE-TIME value refers to the first
-        // occurrence of the referenced time.   Thus, TZID=America/
-        // New_York:20071104T013000 indicates November 4, 2007 at 1:30 A.M.
-        // EDT (UTC-04:00).  If the local time described does not occur (when
-        // changing from standard to daylight time), the DATE-TIME value is
-        // interpreted using the UTC offset before the gap in local times.
-        // Thus, TZID=America/New_York:20070311T023000 indicates March 11,
-        // 2007 at 3:30 A.M. EDT (UTC-04:00), one hour after 1:30 A.M. EST
-        // (UTC-05:00).
-        var lenientZonedDateTime = localDt.InZoneLeniently(zone).WithZone(zone);
-
-        return lenientZonedDateTime;
-    }
-
-    public static ZonedDateTime FromTimeZoneToTimeZone(DateTime dateTime, string fromZoneId, string toZoneId)
-        => FromTimeZoneToTimeZone(dateTime, GetZone(fromZoneId), GetZone(toZoneId));
-
-    public static ZonedDateTime FromTimeZoneToTimeZone(DateTime dateTime, DateTimeZone fromZone, DateTimeZone toZone)
-    {
-        var oldZone = LocalDateTime.FromDateTime(dateTime).InZoneLeniently(fromZone);
-        var newZone = oldZone.WithZone(toZone);
-        return newZone;
-    }
-
-    /// <summary>
-    /// Truncate to the specified TimeSpan's magnitude. For example, to truncate to the nearest second, use TimeSpan.FromSeconds(1)
-    /// </summary>
-    /// <param name="dateTime"></param>
-    /// <param name="timeSpan"></param>
-    /// <returns></returns>
-    public static DateTime Truncate(this DateTime dateTime, TimeSpan timeSpan)
-        => timeSpan == TimeSpan.Zero
-            ? dateTime
-            : dateTime.AddTicks(-(dateTime.Ticks % timeSpan.Ticks));
-
     public static int WeekOfMonth(DateTime d)
     {
         var isExact = d.Day % 7 == 0;
@@ -123,21 +37,4 @@ public static int WeekOfMonth(DateTime d)
     /// </remarks>
     internal static DataTypes.Duration ToDurationExact(this TimeSpan timeSpan)
         => DataTypes.Duration.FromTimeSpanExact(timeSpan);
-
-    /// <summary>
-    /// Creates an instance that represents the given time span, treating the days as nominal duration and the time part as exact.
-    /// </summary>
-    /// <remarks>
-    /// According to RFC5545 the weeks and day fields of a duration are considered nominal durations while the time fields are considered exact values.
-    /// </remarks>
-    internal static DataTypes.Duration ToDuration(this TimeSpan timeSpan)
-        => DataTypes.Duration.FromTimeSpan(timeSpan);
-
-    internal static CalDateTime AddLeniently(this CalDateTime dt, DataTypes.Duration d)
-    {
-        if (d.HasTime && !dt.HasTime)
-            dt = new CalDateTime(dt.Date, TimeOnly.MinValue);
-
-        return dt.Add(d);
-    }
 }
diff --git a/Ical.Net/VTimeZoneInfo.cs b/Ical.Net/VTimeZoneInfo.cs
index fda7d67d1..139545c3e 100644
--- a/Ical.Net/VTimeZoneInfo.cs
+++ b/Ical.Net/VTimeZoneInfo.cs
@@ -9,6 +9,7 @@
 using Ical.Net.CalendarComponents;
 using Ical.Net.DataTypes;
 using Ical.Net.Evaluation;
+using NodaTime;
 
 namespace Ical.Net;
 
@@ -160,6 +161,9 @@ public virtual RecurrenceIdentifier? RecurrenceIdentifier
 
     public IEvaluator? Evaluator => _evaluator;
 
-    public virtual IEnumerable<Occurrence> GetOccurrences(CalDateTime? startTime = null, EvaluationOptions? options = null)
-        => RecurrenceUtil.GetOccurrences(this, startTime, options);
+    public virtual IEnumerable<Occurrence> GetOccurrences(ZonedDateTime startTime, EvaluationOptions? options = null)
+        => RecurrenceUtil.GetOccurrences(this, startTime.Zone, startTime.ToInstant(), options);
+
+    public virtual IEnumerable<Occurrence> GetOccurrences(DateTimeZone timeZone, Instant? startTime = null, EvaluationOptions? options = null)
+        => RecurrenceUtil.GetOccurrences(this, timeZone, startTime, options);
 }