Updated translations.

Introduce a dedicated settings page that lets users reorder, hide,
and pin/unpin folders per account. Folders are organized into Pinned,
Categories (Gmail only), and More sections with drag-to-reorder via
ListView. New Order column on MailItemFolder persists the custom
layout; the default sort falls back to alphabetic when no custom
order is set. A reset action wipes all customization in a single
transaction and restores system-folder stickiness.

Co-authored-by: Claude <noreply@anthropic.com>

.editorconfig

@@ -8,6 +8,9 @@ dotnet_style_operator_placement_when_wrapping = beginning_of_line
 tab_width = 4
 indent_size = 4
 end_of_line = crlf
+[XamlTypeInfo.g.cs]
+dotnet_diagnostic.CS0612.severity = none
+dotnet_diagnostic.CS0618.severity = none
 dotnet_style_coalesce_expression = true:suggestion
 dotnet_style_null_propagation = true:suggestion
 dotnet_style_prefer_is_null_check_over_reference_equality_method = true:suggestion
@@ -149,7 +152,7 @@ csharp_preferred_modifier_order = public,private,protected,internal,static,exter
 # Code-block preferences
 csharp_prefer_braces = true:silent
 csharp_prefer_simple_using_statement = true:suggestion
-csharp_style_namespace_declarations = block_scoped:silent
+csharp_style_namespace_declarations = file_scoped:error
 
 # Expression-level preferences
 csharp_prefer_simple_default_expression = true:suggestion
@@ -287,4 +290,6 @@ csharp_style_prefer_top_level_statements = true:silent
 csharp_style_prefer_utf8_string_literals = true:suggestion
 csharp_style_prefer_readonly_struct = true:suggestion
 csharp_style_allow_blank_line_after_token_in_conditional_expression_experimental = true:silent
-csharp_style_allow_blank_line_after_token_in_arrow_expression_clause_experimental = true:silent
+csharp_style_allow_blank_line_after_token_in_arrow_expression_clause_experimental = true:silent
+csharp_style_prefer_primary_constructors = true:silent
+csharp_prefer_system_threading_lock = true:suggestion

.github/copilot-instructions.md

@@ -0,0 +1,191 @@
+# Copilot Instructions for Wino-Mail Project
+
+## Project Overview
+
+Wino Mail is a native Windows mail client targeting Windows 10 1809+ and Windows 11. The project is **transitioning from UWP to WinUI 3** - always work with WinUI projects (Wino.Mail.WinUI, Wino.Core.WinUI), never edit the old Wino.Mail UWP project.
+
+### Key Technologies
+- **WinUI 3** for UI (previously UWP/WinUI 2)
+- **MVVM Toolkit** (CommunityToolkit.Mvvm) for ViewModels with source generators
+- **Messenger** pattern (WeakReferenceMessenger.Default) for event pub-sub throughout the codebase
+- **SQLite** database stored in publisher cache folder (not local storage)
+- **WebView2** for mail rendering/composition with custom HTML/JavaScript editors
+- **MimeKit/MailKit** for IMAP/SMTP operations
+- **Microsoft Graph SDK** for Outlook synchronization
+- **Gmail API** for Gmail synchronization
+
+### Solution Structure
+```
+Wino.Core.Domain       → Entities, interfaces, translations, enums (shared contracts)
+Wino.Core              → Synchronization engine, authenticators, request processing
+Wino.Services          → Database, mail, folder, account services
+Wino.Mail.ViewModels   → Mail-specific ViewModels
+Wino.Core.ViewModels   → Shared ViewModels (settings, personalization)
+Wino.Mail.WinUI        → **Active WinUI 3 UI project** (use this)
+Wino.Mail              → **Deprecated UWP project** (DO NOT EDIT)
+```
+
+## Architecture Patterns
+
+### Mail Synchronization Flow
+1. **WinoRequestDelegator** → Validates and delegates user actions (mark read, delete, move)
+2. **WinoRequestProcessor** → Batches requests using RequestComparer, queues to synchronizers
+3. **Synchronizers** (OutlookSynchronizer, GmailSynchronizer, ImapSynchronizer) → Execute batched operations
+4. **ChangeProcessors** (OutlookChangeProcessor, etc.) → Apply changes to local database
+5. Database updates trigger **Messenger** events (MailAddedMessage, MailUpdatedMessage, etc.)
+
+### Queue-Based Sync (New Pattern - See QUEUE_SYNC_IMPLEMENTATION.md)
+- Initial sync now queues mail IDs first (MailItemQueue table), downloads metadata only (no MIME)
+- MIME content downloaded on-demand when user opens mail
+- Synchronizers override `QueueMailIdsForInitialSyncAsync()`, `DownloadMailsFromQueueAsync()`, `CreateMinimalMailCopyAsync()`
+- Check `MailItemFolder.IsInitialSyncCompleted` to determine sync state
+
+### Dependency Injection Setup
+Services registered in extension methods across projects:
+- `RegisterCoreServices()` in Wino.Core/CoreContainerSetup.cs
+- `RegisterSharedServices()` in Wino.Services/ServicesContainerSetup.cs
+- `RegisterCoreUWPServices()` in CoreUWPContainerSetup.cs
+- ViewModels registered in App.xaml.cs with AddTransient/AddSingleton
+
+### Messenger Pattern (Event Pub-Sub)
+- All ViewModels inherit from CoreBaseViewModel or MailBaseViewModel which implement IRecipient<T>
+- Register/unregister message handlers in `RegisterRecipients()` / `UnregisterRecipients()`
+- Send messages via `WeakReferenceMessenger.Default.Send(new MessageType(...))`
+- Common messages: MailAddedMessage, MailUpdatedMessage, NavigationRequested, ThemeChanged
+
+## ViewModels Development Guidelines
+
+### Observable Properties - Critical Pattern
+- **ALWAYS** use `public partial` observable properties with MVVM Toolkit source generators
+- **NEVER** use private fields with `[ObservableProperty]` attribute
+- **Correct:**
+  ```csharp
+  [ObservableProperty]
+  public partial string SearchQuery { get; set; } = string.Empty;
+  ```
+- **Incorrect:**
+  ```csharp
+  [ObservableProperty]
+  private string searchQuery = string.Empty;  // WRONG - will not work
+  ```
+
+### ViewModels Structure
+- Inherit from MailBaseViewModel (for mail features) or CoreBaseViewModel (for shared features)
+- Use `[RelayCommand]` for command methods - source generator creates Command properties
+- Implement IRecipient<TMessage> for message handlers
+- Use `IMailDialogService` for Mail-related dialogs, `IDialogServiceBase` for core dialogs
+- Call `RegisterRecipients()` in constructor/OnNavigatedTo, `UnregisterRecipients()` in OnNavigatedFrom
+
+## Localization System
+
+### Translation Workflow (Custom T4-based System)
+1. Add English strings ONLY to `Wino.Core.Domain/Translations/en_US/resources.json`
+2. Build the project - source generators automatically create Translator properties
+3. Use `Translator.{PropertyName}` in ViewModels, XAML (with x:Bind, OneTime mode)
+4. **NEVER** edit other language files - Crowdin manages translations automatically
+5. **NEVER** hardcode user-facing strings
+
+### Usage Examples
+```csharp
+// ViewModel
+_dialogService.InfoBarMessage(Translator.Info_MissingFolderTitle, message);
+
+// XAML
+<TextBlock Text="{x:Bind Translator.Settings_Title, Mode=OneTime}" />
+```
+
+## UI Data Binding and Converters
+
+### WinUI 3 Automatic Conversions
+- **NEVER** create IValueConverter classes or add them to Converters.xaml
+- **NEVER** use BoolToVisibilityConverter - WinUI 3 SDK automatically converts bool to Visibility
+- Direct binding: `Visibility="{x:Bind IsVisible, Mode=OneWay}"`
+- Register control events (for example `Loaded`, `Unloaded`, `SizeChanged`, `PointerEntered`) in XAML markup, not with `+=` in `.xaml.cs`.
+
+### XamlHelpers for Complex Conversions
+- **ALWAYS** use XamlHelpers static methods instead of converters
+- Add xmlns: `xmlns:helpers="using:Wino.Helpers"`
+- Usage: `{x:Bind helpers:XamlHelpers.ReverseBoolToVisibilityConverter(PropertyName), Mode=OneWay}`
+- Available methods: ReverseBoolToVisibilityConverter, CountToBooleanConverter, BoolToSelectionMode, Base64ToBitmapImage
+- Add new methods to XamlHelpers.cs when needed, don't create converters
+
+## WebView2 Mail Rendering
+
+### Architecture
+- **reader.html** (Wino.Mail.WinUI/JS/) for reading mails
+- **editor.html** for composing mails (uses Jodit editor, not Quill as originally planned)
+- WebView2 uses virtual host mapping: `https://wino.mail/reader.html`
+- JavaScript interop via `ExecuteScriptFunctionAsync()` to call functions like `RenderHTML()`
+- MIME content downloaded on-demand, not during sync
+
+### Key Patterns
+- Set environment variables for WebView2 before initialization (overlay scrollbars, cache)
+- Wait for DOMContentLoaded event before script execution
+- Handle theme changes by updating editor CSS dynamically
+- Cancel external navigation, open in browser via Launcher.LaunchUriAsync()
+
+## File Structure and Project Organization
+
+### Critical Rules
+- **NEVER** edit files in Wino.Mail (UWP) project - it's deprecated
+- **ALWAYS** work with Wino.Mail.WinUI for UI components
+- Place ViewModels in Wino.Mail.ViewModels (mail-specific) or Wino.Core.ViewModels (shared)
+- Create abstract base classes in Views/Abstract folders
+- Mail-specific dialog services go in Wino.Mail.WinUI/Services
+
+### Database and Storage
+- SQLite database in publisher cache folder (not app local storage)
+- EML files stored in app local storage, referenced by MailCopy.FileId
+- Paths resolved via MimeFileService.GetMimeMessagePath()
+- Database entities in Wino.Core.Domain/Entities
+
+## Error Handling and User Feedback
+
+### Exception Handling Patterns
+```csharp
+try {
+    await operation();
+} catch (UnavailableSpecialFolderException ex) {
+    _dialogService.InfoBarMessage(title, message, InfoBarMessageType.Warning, buttonText, action);
+} catch (NotImplementedException) {
+    _dialogService.ShowNotSupportedMessage();
+}
+```
+
+### Dialog Service Methods
+- `InfoBarMessage()` - simple notifications with optional action button
+- `ShowConfirmationDialogAsync()` - yes/no dialogs
+- `PickFilesAsync()` - file selection
+- Always check for null/empty results from dialog operations
+
+## Code Style and Best Practices
+
+- Use `var` where type is obvious from right side
+- String interpolation over string.Format for simple cases
+- Keep methods focused and single-responsibility
+- Add XML documentation for public APIs
+- Avoid introducing new NuGet packages - maximize use of existing libraries
+- Wrap async operations in try-catch blocks
+- Log errors via IWinoLogger but don't expose technical details to users
+
+## Development Workflow
+
+### Building and Running
+- Open WinoMail.slnx in Visual Studio 2022+
+- Target platforms: x86, x64, ARM64 (ARM32 being phased out)
+- Minimum: Windows 10 1809, Target: Windows 11 22H2
+- Set Wino.Mail.WinUI as startup project
+
+### Testing
+- Test suite in Wino.Core.Tests
+- Manual testing required for UI/WebView2 interactions
+- Test synchronization with real accounts when modifying synchronizers
+
+### Common Pitfalls
+- Forgetting to register ViewModels in App.xaml.cs RegisterViewModels()
+- Not calling RegisterRecipients() for message handlers
+- Using private fields with [ObservableProperty] (won't work - must be public partial)
+- Creating IValueConverter classes instead of using XamlHelpers
+- Editing UWP project files instead of WinUI equivalents
+- Hardcoding strings instead of using Translator
+- Forgetting to unregister Messenger recipients (memory leaks)

.github/workflows/beta-release.yml

@@ -0,0 +1,187 @@
+name: Manual Beta Release
+
+on:
+  workflow_dispatch:
+    inputs:
+      release_title:
+        description: Optional GitHub release title override
+        required: false
+        type: string
+
+permissions:
+  contents: write
+  packages: read
+
+jobs:
+  release-beta:
+    name: Build and publish beta release
+    runs-on: windows-latest
+    env:
+      PROJECT_PATH: Wino.Mail.WinUI/Wino.Mail.WinUI.csproj
+      MANIFEST_PATH: Wino.Mail.WinUI/Package.appxmanifest
+      CHANGELOG_PATH: CHANGELOG.md
+      NUGET_CONFIG_PATH: ${{ github.workspace }}\nuget.config
+      PACKAGE_OUTPUT_DIR: ${{ github.workspace }}\artifacts\package
+      RELEASE_OUTPUT_DIR: ${{ github.workspace }}\artifacts\release
+      CERTIFICATE_PFX_PATH: ${{ github.workspace }}\artifacts\signing\beta-signing-cert.pfx
+      CERTIFICATE_CER_PATH: ${{ github.workspace }}\artifacts\release\Wino-Mail-Beta.cer
+    steps:
+      - name: Checkout selected branch
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ github.ref }}
+          fetch-depth: 0
+
+      - name: Fetch tags from origin
+        shell: pwsh
+        run: git fetch origin --force --tags
+
+      - name: Validate release secrets
+        shell: pwsh
+        env:
+          BETA_SIGNING_CERT_PFX_BASE64: ${{ secrets.BETA_SIGNING_CERT_PFX_BASE64 }}
+        run: |
+          if ([string]::IsNullOrWhiteSpace($env:BETA_SIGNING_CERT_PFX_BASE64)) {
+            throw "Missing required secret: BETA_SIGNING_CERT_PFX_BASE64"
+          }
+
+      - name: Setup .NET SDK
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: 10.0.x
+        env:
+          NUGET_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Compute beta version and release metadata
+        id: metadata
+        shell: pwsh
+        env:
+          RELEASE_TITLE_INPUT: ${{ github.event.inputs.release_title }}
+        run: |
+          $manifestPath = Join-Path $env:GITHUB_WORKSPACE $env:MANIFEST_PATH
+          if (-not (Test-Path $manifestPath)) {
+            throw "Package manifest not found: $manifestPath"
+          }
+
+          $changelogPath = Join-Path $env:GITHUB_WORKSPACE $env:CHANGELOG_PATH
+          if (-not (Test-Path $changelogPath)) {
+            throw "Release notes file not found: $changelogPath"
+          }
+
+          [xml]$manifest = Get-Content -LiteralPath $manifestPath
+          $identityNode = $manifest.Package.Identity
+          if (-not $identityNode) {
+            throw "Could not locate the Package/Identity node in $manifestPath"
+          }
+
+          $currentVersionText = [string]$identityNode.Version
+          if ($currentVersionText -notmatch '^(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)\.(?<revision>\d+)$') {
+            throw "Manifest version '$currentVersionText' is not a four-part numeric version."
+          }
+
+          $packageVersion = $currentVersionText
+          $releaseTag = "v$packageVersion"
+          $releaseTitleInput = $env:RELEASE_TITLE_INPUT
+          $releaseTitle = if ([string]::IsNullOrWhiteSpace($releaseTitleInput)) { $releaseTag } else { $releaseTitleInput.Trim() }
+
+          $headSha = (git rev-parse HEAD).Trim()
+          if ([string]::IsNullOrWhiteSpace($headSha)) {
+            throw "Failed to resolve the checked out commit SHA."
+          }
+
+          $notesInput = Get-Content -LiteralPath $changelogPath -Raw
+          if ([string]::IsNullOrWhiteSpace($notesInput)) {
+            throw "Release notes file is empty: $changelogPath"
+          }
+
+          $notesInput = $notesInput.Trim()
+          New-Item -ItemType Directory -Path $env:RELEASE_OUTPUT_DIR -Force | Out-Null
+          $releaseNotesPath = Join-Path $env:RELEASE_OUTPUT_DIR 'beta-release-notes.md'
+          $notesInput | Set-Content -LiteralPath $releaseNotesPath -Encoding utf8
+
+          "package_version=$packageVersion" >> $env:GITHUB_OUTPUT
+          "release_tag=$releaseTag" >> $env:GITHUB_OUTPUT
+          "release_title=$releaseTitle" >> $env:GITHUB_OUTPUT
+          "release_notes_path=$releaseNotesPath" >> $env:GITHUB_OUTPUT
+          "head_sha=$headSha" >> $env:GITHUB_OUTPUT
+
+      - name: Materialize signing certificate
+        shell: pwsh
+        env:
+          BETA_SIGNING_CERT_PFX_BASE64: ${{ secrets.BETA_SIGNING_CERT_PFX_BASE64 }}
+        run: |
+          $signingDir = Split-Path -Parent $env:CERTIFICATE_PFX_PATH
+          New-Item -ItemType Directory -Path $signingDir -Force | Out-Null
+          [IO.File]::WriteAllBytes($env:CERTIFICATE_PFX_PATH, [Convert]::FromBase64String($env:BETA_SIGNING_CERT_PFX_BASE64))
+
+          $certificate = New-Object System.Security.Cryptography.X509Certificates.X509Certificate2($env:CERTIFICATE_PFX_PATH, $null, [System.Security.Cryptography.X509Certificates.X509KeyStorageFlags]::Exportable)
+
+          New-Item -ItemType Directory -Path (Split-Path -Parent $env:CERTIFICATE_CER_PATH) -Force | Out-Null
+          [IO.File]::WriteAllBytes($env:CERTIFICATE_CER_PATH, $certificate.Export([System.Security.Cryptography.X509Certificates.X509ContentType]::Cert))
+
+      - name: Restore WinUI project dependencies
+        shell: pwsh
+        run: |
+          if (-not (Test-Path $env:NUGET_CONFIG_PATH)) {
+            throw "NuGet config file not found: $env:NUGET_CONFIG_PATH"
+          }
+
+          dotnet restore $env:PROJECT_PATH `
+            --configfile $env:NUGET_CONFIG_PATH `
+            -p:Platform=x64 `
+            /p:RestoreConfigFile="$env:NUGET_CONFIG_PATH"
+
+      - name: Build MSIX bundle
+        shell: pwsh
+        run: |
+          New-Item -ItemType Directory -Path $env:PACKAGE_OUTPUT_DIR -Force | Out-Null
+
+          dotnet build $env:PROJECT_PATH `
+            --configuration Release `
+            --no-restore `
+            --configfile $env:NUGET_CONFIG_PATH `
+            /p:Platform=x64 `
+            /p:RestoreConfigFile="$env:NUGET_CONFIG_PATH" `
+            /p:GenerateAppxPackageOnBuild=true `
+            /p:UapAppxPackageBuildMode=SideloadOnly `
+            /p:AppxBundle=Always `
+            /p:AppxBundlePlatforms="x86|x64|arm64" `
+            /p:AppxPackageDir="$env:PACKAGE_OUTPUT_DIR\\" `
+            /p:AppxPackageVersion=${{ steps.metadata.outputs.package_version }} `
+            /p:PackageCertificateKeyFile="$env:CERTIFICATE_PFX_PATH" `
+            /p:PackageCertificatePassword= `
+            /p:PackageCertificateThumbprint= `
+            /p:AppxPackageSigningEnabled=true
+
+      - name: Collect packaged artifacts
+        id: package
+        shell: pwsh
+        run: |
+          $bundle = Get-ChildItem -Path $env:PACKAGE_OUTPUT_DIR -Recurse -Filter *.msixbundle | Select-Object -First 1
+          if (-not $bundle) {
+            throw "No .msixbundle file was generated under $env:PACKAGE_OUTPUT_DIR"
+          }
+
+          $releaseAssetPath = Join-Path $env:RELEASE_OUTPUT_DIR "Wino_${{ steps.metadata.outputs.package_version }}.zip"
+          if (Test-Path $releaseAssetPath) {
+            Remove-Item -LiteralPath $releaseAssetPath -Force
+          }
+
+          Compress-Archive -LiteralPath @($bundle.FullName, $env:CERTIFICATE_CER_PATH) -DestinationPath $releaseAssetPath -Force
+
+          "bundle_path=$($bundle.FullName)" >> $env:GITHUB_OUTPUT
+          "bundle_name=$($bundle.Name)" >> $env:GITHUB_OUTPUT
+          "release_asset_path=$releaseAssetPath" >> $env:GITHUB_OUTPUT
+
+      - name: Create GitHub prerelease
+        shell: pwsh
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          gh release create "${{ steps.metadata.outputs.release_tag }}" `
+            "${{ steps.package.outputs.release_asset_path }}" `
+            --repo "${{ github.repository }}" `
+            --target "${{ steps.metadata.outputs.head_sha }}" `
+            --title "${{ steps.metadata.outputs.release_title }}" `
+            --notes-file "${{ steps.metadata.outputs.release_notes_path }}" `
+            --prerelease

.gitignore

@@ -206,9 +206,6 @@ PublishScripts/
 *.nuget.props
 *.nuget.targets
 
-# Nuget personal access tokens and Credentials
-nuget.config
-
 # Microsoft Azure Build Output
 csx/
 *.build.csdef
@@ -402,3 +399,5 @@ Wino/obj/x86/Debug/XamlSaveStateFile.xml
 Wino/obj/x86/Debug/XamlSaveStateFile.xml
 *.cache
 .vs/Wino/v16/.suo
+/.claude/settings.local.json
+scripts/translate_resources.local.bat

AGENTS.md

@@ -0,0 +1,163 @@
+# AGENTS.md
+
+This file provides guidance to AI agent when working with code in this repository.
+
+## Project Overview
+
+Wino Mail is a native Windows mail client (Windows 10 1809+ / Windows 11) replacing the deprecated Windows Mail & Calendar. It's **transitioning from UWP to WinUI 3** - always work with WinUI projects (Wino.Mail.WinUI), never edit the deprecated Wino.Mail UWP project.
+
+## Build and Development Commands
+
+```bash
+# Open solution
+# WinoMail.slnx is the main solution file (VS 2022+)
+
+# Build WinUI project (Debug x64)
+dotnet restore Wino.Mail.WinUI/Wino.Mail.WinUI.csproj --configfile nuget.config -p:Platform=x64 -p:RuntimeIdentifier=win-x64 && dotnet build Wino.Mail.WinUI/Wino.Mail.WinUI.csproj -c Debug --no-restore /p:Platform=x64 /p:RuntimeIdentifier=win-x64 /p:GenerateAppxPackageOnBuild=false /p:AppxPackageSigningEnabled=false
+
+# Build WinUI project with diagnostic XAML/compiler logging (use when plain build only shows "XamlCompiler.exe exited with code 1")
+dotnet build Wino.Mail.WinUI/Wino.Mail.WinUI.csproj -c Debug --no-restore /p:Platform=x64 /p:RuntimeIdentifier=win-x64 /p:GenerateAppxPackageOnBuild=false /p:AppxPackageSigningEnabled=false "/flp:logfile=winui-build.log;verbosity=diagnostic" /bl:winui-build.binlog
+
+# Run tests (Debug x64)
+dotnet test Wino.Core.Tests/Wino.Core.Tests.csproj -c Debug /p:Platform=x64
+
+# Copilot CLI build command (Debug x64)
+dotnet restore Wino.Mail.WinUI/Wino.Mail.WinUI.csproj --configfile nuget.config -p:Platform=x64 -p:RuntimeIdentifier=win-x64 && dotnet build Wino.Mail.WinUI/Wino.Mail.WinUI.csproj -c Debug --no-restore /p:Platform=x64 /p:RuntimeIdentifier=win-x64 /p:GenerateAppxPackageOnBuild=false /p:AppxPackageSigningEnabled=false
+```
+
+**Prerequisites:** Visual Studio 2022+ with ".NET desktop development" workload, .NET SDK 10+
+
+**Startup project:** Wino.Mail.WinUI
+
+**Platforms:** x86, x64, ARM64
+
+## Efficient Workflow
+
+- Start with targeted symbol or file search before reading full files
+- Prefer one focused task per thread; use a new thread for unrelated follow-up work
+- Keep verification narrow: build only the affected project, not the full solution, unless cross-project changes require it
+- After the first restore, prefer `--no-restore` builds unless package or project references changed
+- Summarize long build logs and inspect only the files named in diagnostics instead of loading large logs into context
+- When the prompt already names likely files, types, or symbols, start there instead of re-mapping the repository
+- If a WinUI build only reports `XamlCompiler.exe exited with code 1`, rerun with the diagnostic logging command above and inspect the terminal output plus `winui-build.log` for real `WMC`/`WMC1121`/binding diagnostics before guessing
+
+## Architecture
+
+### Solution Structure
+```
+Wino.Core.Domain       → Entities, interfaces, translations, enums (shared contracts)
+Wino.Core              → Synchronization engine, authenticators, request processing
+Wino.Services          → Database, mail, folder, account services
+Wino.Authentication    → OAuth2 authenticators (Outlook, Gmail)
+Wino.Mail.ViewModels   → Mail-specific ViewModels
+Wino.Core.ViewModels   → Shared ViewModels (settings, personalization)
+Wino.Messaging         → Pub-sub message definitions
+Wino.Mail.WinUI        → **Active WinUI 3 UI project** (use this)
+Wino.Mail              → **Deprecated UWP project** (DO NOT EDIT)
+```
+
+### Mail Synchronization Flow
+1. **WinoRequestDelegator** → Validates and delegates user actions (mark read, delete, move)
+2. **WinoRequestProcessor** → Batches requests using RequestComparer, queues to synchronizers
+3. **Synchronizers** (OutlookSynchronizer, GmailSynchronizer, ImapSynchronizer) → Execute batched operations
+4. **ChangeProcessors** → Apply changes to local SQLite database
+5. Database updates trigger **Messenger** events (MailAddedMessage, MailUpdatedMessage, etc.)
+
+### Synchronizer Types
+- **OutlookSynchronizer** - Microsoft Graph SDK for Office 365
+- **GmailSynchronizer** - Gmail API
+- **ImapSynchronizer** - MimeKit/MailKit for IMAP/SMTP
+
+### Queue-Based Sync Pattern
+- Initial sync queues mail IDs first (MailItemQueue table), downloads metadata only
+- MIME content downloaded on-demand when user opens mail
+- Check `MailItemFolder.IsInitialSyncCompleted` for sync state
+- See QUEUE_SYNC_IMPLEMENTATION.md for details
+
+### Dependency Injection
+- `RegisterCoreServices()` in Wino.Core/CoreContainerSetup.cs
+- `RegisterSharedServices()` in Wino.Services/ServicesContainerSetup.cs
+- ViewModels registered in App.xaml.cs
+
+## Key Patterns
+
+### MVVM with Source Generators
+**CORRECT - use public partial properties:**
+```csharp
+[ObservableProperty]
+public partial string SearchQuery { get; set; } = string.Empty;
+```
+
+**WRONG - will not work:**
+```csharp
+[ObservableProperty]
+private string searchQuery = string.Empty;
+```
+
+### Messenger Pattern
+- ViewModels inherit from CoreBaseViewModel or MailBaseViewModel
+- Register handlers in `RegisterRecipients()`, unregister in `UnregisterRecipients()`
+- Send via `WeakReferenceMessenger.Default.Send(new MessageType(...))`
+
+### Data Binding - No Converters
+- **NEVER** create IValueConverter classes
+- WinUI 3 auto-converts bool to Visibility: `Visibility="{x:Bind IsVisible, Mode=OneWay}"`
+- Use XamlHelpers for complex conversions: `{x:Bind helpers:XamlHelpers.ReverseBoolToVisibilityConverter(Prop)}`
+- `x:Bind` does not implicitly convert `double` to `GridLength`; when binding `RowDefinition.Height` or `ColumnDefinition.Width`, use a `XamlHelpers` method such as `DoubleToGridLength(...)`
+- For `ComboBox` controls in XAML, never use `DisplayMemberPath` or `SelectedValuePath`; use a typed `ItemTemplate` and bind `SelectedItem` explicitly, preferably with `x:Bind`
+
+## Localization
+
+1. Add English strings ONLY to Wino.Core.Domain/Translations/en_US/resources.json
+2. Build project - source generators create Translator properties
+3. Use Translator.{PropertyName} in code/XAML
+4. NEVER edit any resources.json file outside Wino.Core.Domain/Translations/en_US/resources.json
+5. Treat all non-en_US translation files as managed externally and leave them untouched, even when adding new localization keys
+6. In XAML, translation bindings must use `Mode=OneTime` because `Wino.Core.Domain/Translator.cs` does not implement `INotifyPropertyChanged`
+
+## Storage
+
+- **SQLite database** in publisher cache folder (shared with future Wino Calendar)
+- **EML files** in app local storage, referenced by `MailCopy.FileId`
+- Paths resolved via `MimeFileService.GetMimeMessagePath()`
+
+## WebView2 Mail Rendering
+
+- `reader.html` for reading mails, `editor.html` for composing (Jodit editor)
+- Virtual host mapping: `https://wino.mail/reader.html`
+- JavaScript interop via `ExecuteScriptFunctionAsync()`
+- MIME content downloaded on-demand, not during sync
+
+## Common Pitfalls
+
+- Forgetting to register ViewModels in App.xaml.cs `RegisterViewModels()`
+- Not calling `RegisterRecipients()` for message handlers
+- Using private fields with `[ObservableProperty]` instead of public partial
+- Creating IValueConverter classes instead of using XamlHelpers
+- Editing UWP project files instead of WinUI equivalents
+- Hardcoding strings instead of using Translator
+- Forgetting to unregister Messenger recipients (memory leaks)
+- Putting authentication validation, token refresh, account API calls, settings serialization/deserialization, or preference-application logic into ViewModels instead of the corresponding service
+
+## Code Style
+
+- Avoid introducing new NuGet packages when possible
+- Use existing libraries (MimeKit, MailKit, Microsoft Graph, Gmail API)
+- Use `var` where type is obvious
+- String interpolation over string.Format
+- Wrap async operations in try-catch
+- Log errors via IWinoLogger
+- For dependency properties in WinUI code, always prefer `[GeneratedDependencyProperty]` from CommunityToolkit over manual `DependencyProperty.Register(...)` declarations.
+- When a `[RelayCommand]` needs enable/disable logic, prefer the command's `CanExecute` over binding `Button.IsEnabled` in XAML; use `[NotifyCanExecuteChangedFor]` on dependent properties and call `NotifyCanExecuteChanged()` explicitly when non-generated state affects the command.
+- In ViewModels, update all UI-bound properties/collections via `ExecuteUIThread(...)` (especially after awaited calls and any use of `ConfigureAwait(false)`).
+- `ConfigureAwait(false)` continues execution on a background thread. Any UI-bound property change, `INotifyPropertyChanged` notification, collection mutation, or similar UI-facing state update after that point must be marshaled back with `ExecuteUIThread(...)` or the appropriate dispatcher call, otherwise the app can crash.
+- Messenger messages are raised from a background thread by default, while UI control event handlers such as `Button.Click` start on the UI thread. Be deliberate when combining dispatcher usage with `ConfigureAwait(false)` so post-await UI updates always return to the UI thread.
+- ViewModels should only handle UI interaction/state and delegate business logic to services; account-management work belongs in `WinoAccountProfileService`, and preferences import/export/apply logic belongs in `PreferencesService`.
+- In `EventDetailsPageViewModel.LoadAttendeesAsync`, never mutate `CurrentEvent.Attendees` outside `ExecuteUIThread(...)`.
+- Never create pure C# controls or controls that heavily manipulate UI structure from `.cs` files. Define controls in XAML and keep UI composition in XAML.
+- Never add XAML-backed UI controls to `.xaml.cs`. If a view has XAML, all control declarations, flyouts, templates, and visual composition belong in the `.xaml` file; keep `.xaml.cs` limited to event handling and view glue.
+- Never subscribe to framework events like `Loaded`, `Unloaded`, or input events from constructors in `.xaml.cs` for XAML-backed controls and pages; wire them directly in XAML instead.
+- If you use `x:Load` in XAML, always give that `UIElement` an `x:Name`.
+
+
+

CONTRIBUTING.md

@@ -15,7 +15,12 @@ Wino Mail is [Universal Windows Platform](https://learn.microsoft.com/en-us/wind
 **Min Version:** Windows 10 1809 
 **Target Version:** Windows 11 22H2
 
-It's pretty straightforward after cloning the repo. There are no prerequisites needed. Just open **Wino.sln** solution in your IDE and launch.
+## Prerequisites
+
+* ".NET desktop development" workload in Visual Studio 2022+
+* .NET SDK 8.0+
+
+With those installed, it's pretty straightforward after cloning the repo.  Just open **Wino.sln** solution in your IDE and launch.
 
 ## Project Architecture
 

Directory.Build.Props

@@ -0,0 +1,7 @@
+<Project>
+	<PropertyGroup>
+		<LangVersion>preview</LangVersion>
+		<IsAotCompatible>true</IsAotCompatible>
+		<Configurations>Debug;Release</Configurations>
+	</PropertyGroup>
+</Project>

Directory.Packages.props

@@ -0,0 +1,80 @@
+<Project>
+  <PropertyGroup>
+    <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageVersion Include="ColorHashSharp" Version="1.1.0" />
+    <PackageVersion Include="CommunityToolkit.Common" Version="8.4.2" />
+    <PackageVersion Include="CommunityToolkit.Diagnostics" Version="8.4.2" />
+    <PackageVersion Include="CommunityToolkit.Mvvm" Version="8.4.2" />
+    <PackageVersion Include="CommunityToolkit.WinUI.Animations" Version="8.2.251219" />
+    <PackageVersion Include="CommunityToolkit.WinUI.Controls.Segmented" Version="8.2.251219" />
+    <PackageVersion Include="CommunityToolkit.WinUI.Controls.SettingsControls" Version="8.2.251219" />
+    <PackageVersion Include="CommunityToolkit.WinUI.Controls.Sizers" Version="8.2.251219" />
+    <PackageVersion Include="CommunityToolkit.WinUI.Controls.TabbedCommandBar" Version="8.2.251219" />
+    <PackageVersion Include="CommunityToolkit.WinUI.Controls.TokenizingTextBox" Version="8.2.251219" />
+    <PackageVersion Include="CommunityToolkit.WinUI.Extensions" Version="8.2.251219" />
+    <PackageVersion Include="CommunityToolkit.Labs.WinUI.Controls.MarkdownTextBlock" Version="0.1.250926-build.2293" />
+    <PackageVersion Include="CommunityToolkit.WinUI.Lottie" Version="8.2.250604" />
+    <PackageVersion Include="CommunityToolkit.Labs.WinUI.DependencyPropertyGenerator" Version="0.1.250926-build.2293" />
+    <PackageVersion Include="EmailValidation" Version="1.3.0" />
+    <PackageVersion Include="gravatar-dotnet" Version="0.1.3" />
+    <PackageVersion Include="HtmlAgilityPack" Version="1.12.4" />
+    <PackageVersion Include="Ical.Net" Version="5.2.1" />
+    <PackageVersion Include="IsExternalInit" Version="1.0.3" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.Analyzers" Version="5.3.0" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="5.3.0" />
+    <PackageVersion Include="Microsoft.Extensions.DependencyInjection" Version="10.0.6" />
+    <PackageVersion Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="10.0.6" />
+    <PackageVersion Include="Microsoft.Graph" Version="5.104.0" />
+    <PackageVersion Include="Microsoft.Graphics.Win2D" Version="1.4.0" />
+    <PackageVersion Include="Microsoft.Identity.Client" Version="4.83.3" />
+    <PackageVersion Include="Microsoft.Identity.Client.Broker" Version="4.83.3" />
+    <PackageVersion Include="Microsoft.Identity.Client.Extensions.Msal" Version="4.83.3" />
+    <PackageVersion Include="Microsoft.NETCore.UniversalWindowsPlatform" Version="6.2.14" />
+    <PackageVersion Include="Microsoft.Windows.SDK.BuildTools.MSIX" Version="1.7.260316102" />
+    <PackageVersion Include="Microsoft.Xaml.Behaviors.WinUI.Managed" Version="3.0.1" />
+    <PackageVersion Include="Wino.Mail.Contracts" Version="1.0.18" />
+    <PackageVersion Include="MimeKit" Version="4.16.0" />
+    <PackageVersion Include="morelinq" Version="4.4.0" />
+    <PackageVersion Include="Nito.AsyncEx" Version="5.1.2" />
+    <PackageVersion Include="Nito.AsyncEx.Tasks" Version="5.1.2" />
+    <PackageVersion Include="NodaTime" Version="3.3.1" />
+    <PackageVersion Include="Sentry.Serilog" Version="6.4.0" />
+    <PackageVersion Include="Serilog" Version="4.3.1" />
+    <PackageVersion Include="Serilog.Exceptions" Version="8.4.0" />
+    <PackageVersion Include="Serilog.Sinks.Debug" Version="3.0.0" />
+    <PackageVersion Include="Serilog.Sinks.File" Version="7.0.0" />
+    <PackageVersion Include="Serilog.Sinks.ApplicationInsights" Version="4.0.0" />
+    <PackageVersion Include="SkiaSharp" Version="3.119.2" />
+    <PackageVersion Include="SkiaSharp.Views.WinUI" Version="3.119.2" />
+    <PackageVersion Include="sqlite-net-pcl" Version="1.10.196-beta" />
+    <PackageVersion Include="System.Drawing.Common" Version="10.0.5" />
+    <PackageVersion Include="System.Private.Uri" Version="4.3.2" />
+    <PackageVersion Include="System.Text.Encoding.CodePages" Version="9.0.10" />
+    <PackageVersion Include="System.Text.Json" Version="10.0.6" />
+    <PackageVersion Include="H.NotifyIcon.Wpf" Version="2.3.0" />
+    <PackageVersion Include="H.NotifyIcon.WinUI" Version="2.4.1" />
+    <PackageVersion Include="CommunityToolkit.WinUI.Notifications" Version="7.1.2" />
+    <PackageVersion Include="Google.Apis.Auth" Version="1.73.0" />
+    <PackageVersion Include="Google.Apis.Calendar.v3" Version="1.73.0.4073" />
+    <PackageVersion Include="Google.Apis.Drive.v3" Version="1.73.0.4112" />
+    <PackageVersion Include="Google.Apis.Gmail.v1" Version="1.73.0.4029" />
+    <PackageVersion Include="Google.Apis.PeopleService.v1" Version="1.72.0.3973" />
+    <PackageVersion Include="HtmlKit" Version="1.2.0" />
+    <PackageVersion Include="MailKit" Version="4.16.0" />
+    <PackageVersion Include="TimePeriodLibrary.NET" Version="2.1.6" />
+    <PackageVersion Include="System.Reactive" Version="6.1.0" />
+    <PackageVersion Include="Microsoft.Bcl.AsyncInterfaces" Version="10.0.6" />
+    <PackageVersion Include="System.Text.Encodings.Web" Version="10.0.6" />
+    <PackageVersion Include="Microsoft.Windows.SDK.BuildTools" Version="10.0.28000.1721" />
+    <PackageVersion Include="Microsoft.WindowsAppSDK" Version="2.0.250930001-experimental1" />
+    <PackageVersion Include="WinUIEx" Version="2.9.0" />
+    <!-- Testing packages -->
+    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.4.0" />
+    <PackageVersion Include="xunit" Version="2.9.3" />
+    <PackageVersion Include="xunit.runner.visualstudio" Version="3.1.5" />
+    <PackageVersion Include="FluentAssertions" Version="8.9.0" />
+    <PackageVersion Include="Moq" Version="4.20.72" />
+  </ItemGroup>
+</Project>

README.md

@@ -1,45 +1,54 @@
-
 <p align="center">
-  <a href="https://apps.microsoft.com/detail/Wino%20Mail/9NCRCVJC50WL?launch=true
-	&mode=full">
-    <img src="https://www.winomail.app/images/wino_logo.png" width=90 height=90>
+  <a href="https://apps.microsoft.com/detail/Wino%20Mail/9NCRCVJC50WL?launch=true&mode=full">
+    <img src="https://www.winomail.app/images/v2/Logo.png" width="90" height="90" alt="Wino Mail logo">
   </a>
 
   <h3 align="center">Wino Mail</h3>
 
   <p align="center">
-    Native mail client for Windows device families. 
+    Native mail and calendar client for Windows.
   </p>
 </p>
 
 <br>
 
-![pdark](https://user-images.githubusercontent.com/12009960/232114528-2d2c8e3c-dbe7-429a-94e0-6aecc73bdf70.png)
+![Wino Mail screenshot](https://user-images.githubusercontent.com/12009960/232114528-2d2c8e3c-dbe7-429a-94e0-6aecc73bdf70.png)
 
 ## Motivation
 
-I'm a big fan of Windows Mail & Calendars due to its simplicity. Personally, I find it more intuitive for daily use cases compared to Outlook desktop and the new WebView2 powered Outlook version. Seeing [Microsoft deprecating it](https://support.microsoft.com/en-us/office/outlook-for-windows-the-future-of-mail-calendar-and-people-on-windows-11-715fc27c-e0f4-4652-9174-47faa751b199#:~:text=The%20Mail%20and%20Calendar%20applications,will%20no%20longer%20be%20supported.) dragged me into starting to work on Wino a couple of years ago. Wino's main motivation is to bring all the existing functionality from Mail & Calendars over time without changing the user experience that millions have loved since the Windows 8 days in Mail & Calendars
+I'm a big fan of Windows Mail & Calendars due to its simplicity. Personally, I find it more intuitive for daily use cases compared to Outlook desktop and the new WebView2 powered Outlook version. Seeing [Microsoft deprecating it](https://support.microsoft.com/en-us/office/outlook-for-windows-the-future-of-mail-calendar-and-people-on-windows-11-715fc27c-e0f4-4652-9174-47faa751b199#:~:text=The%20Mail%20and%20Calendar%20applications,will%20no%20longer%20be%20supported.) dragged me into starting to work on Wino a couple of years ago. Wino's main motivation is to bring all the existing functionality from Mail & Calendars over time without changing the user experience that millions have loved since the Windows 8 days in Mail & Calendars.
+
+## vNext Release Highlights
+
+Wino vNext focuses on making Mail, Calendar, and Contacts feel like one cohesive native Windows experience while improving sync reliability and startup responsiveness.
+
+- 📅 **Calendar management:** Event compose/create flow, calendar-mail mapping, reminder snooze support, occurrence and detail-page improvements, and CalDAV correctness fixes.
+- 👥 **Contact management:** Improved contact workflows, account/settings integration, and contact data-model cleanup.
+- 🔄 **Synchronization reliability:** Refactored synchronizers, better state handling, 404 + 429 error handling, and duplicate-operation prevention.
+- ✉️ **Compose and drafts:** Refined editor/toolbar architecture, better rendering pipeline, Gmail draft support, and large Outlook attachment upload sessions.
+- ⚡ **Performance and quality:** Faster mail fetching with batched DB queries and caching, SQLite indexing/foreign key enforcement, and broader test + CI coverage.
+- 🎨 **WinUI polish:** Improved onboarding/startup, settings and dialogs refresh, notification routing fixes, and keyboard/navigation quality-of-life improvements.
 
 ## Features
 
-- API integration for Outlook and Gmail
-- IMAP/SMTP support for custom mail servers
-- Send, receive, mark as (read,important,spam etc), move mails.
-- Linked/Merged Accounts
-- Toast notifications with background sync.
-- Instant startup performance
-- Offline use / search.
-- Modern and responsive UI
-- Lots of personalization options
-- Dark / Light mode for mail reader
+- 📨 Outlook and Gmail API integration
+- 🌐 IMAP/SMTP support for custom mail servers
+- 📅 Calendar support with event creation/compose and reminders
+- 👥 Contact management and people-centric account experience
+- ✅ Core mail actions: send, receive, read/unread, move, spam, and more
+- 🔗 Linked/Merged accounts
+- 🔔 Toast notifications with background sync
+- ⚡ Instant startup-oriented architecture
+- 🔎 Offline-capable workflows and search improvements
+- 🎛️ Modern responsive WinUI interface with personalization options
+- 🌗 Dark/Light mode for mail reader and app surfaces
 
 ## Download
 
 Download latest version of Wino Mail from Microsoft Store for free.
 
-<a href="https://apps.microsoft.com/detail/Wino%20Mail/9NCRCVJC50WL?launch=true
-	&mode=full">
-	<img src="https://get.microsoft.com/images/en-us%20dark.svg" width="200"/>
+<a href="https://apps.microsoft.com/detail/Wino%20Mail/9NCRCVJC50WL?launch=true&mode=full">
+	<img src="https://get.microsoft.com/images/en-us%20dark.svg" width="200" alt="Get Wino Mail from Microsoft Store"/>
 </a>
 
 ## Beta Releases
@@ -48,7 +57,6 @@ Stable releases will always be distributed on Microsoft Store. However, beta rel
 
 These releases are distributed as side-loaded packages. To install them, download the **.msixbundle** file in GitHub releases and [follow the steps explained here.](https://learn.microsoft.com/en-us/windows/application-management/sideload-apps-in-windows)
 
-
 ## Contributing
 
 Check out the [contribution guidelines](/CONTRIBUTING.md) before diving into the source code or opening an issue. There are multiple ways to contribute and all of them are explained in detail there.
@@ -59,3 +67,4 @@ Your donations will motivate me more to work on Wino in my spare time and cover
 
 - You can [donate via Paypal by clicking here](https://www.paypal.com/donate/?hosted_button_id=LGPERGGXFMQ7U)
 - You can buy Unlimited Accounts add-on in the application. It's a one-time payment for lifetime, not a monthly recurring payment.
+

RELEASE_NOTES_vNext.md

@@ -0,0 +1,158 @@
+# Wino Mail vNext Improvements
+
+This document summarizes the major improvements on `feature/vNext` compared to `main`, based on the commit history between the current branch and the merge-base with `main`.
+
+## Wino Calendar
+
+Calendar has grown from an early implementation into a much more complete product area on this branch.
+
+### A full Wino Calendar experience
+
+- Added a dedicated Wino Calendar app entry, making calendar a first-class experience instead of a secondary add-on.
+- Built out the calendar rendering experience with multiple rounds of rendering improvements, updated calendar view styling, calendar buttons, and better event visuals.
+- Added event creation and full event compose flows, including follow-up improvements for attachments, attendees, recurrence summaries, RSVP actions, reminders, and event details.
+- Improved support for all-day events, better display dates, occurrence handling, and mail-to-calendar mapping so calendar actions connect more naturally with messages and invitations.
+
+### Local calendar support
+
+- Added local calendar operation coverage and supporting behavior for IMAP-backed/local calendar scenarios.
+- Prevented duplicate operations by ignoring local calendar apply-changes in the wrong paths.
+- Added busy-state support and metadata fetch flows so newly created accounts can initialize calendar data more reliably.
+
+### CalDAV sync
+
+- Introduced a dedicated CalDAV synchronizer and supporting service/client work.
+- Fixed CalDAV delta sync issues.
+- Fixed CalDAV timezone issues.
+- Added manual live CalDAV workflow tests to validate real-world sync behavior.
+
+This means local and self-hosted calendar scenarios are much better represented on this branch than on `main`.
+
+### API calendar sync for Outlook and Gmail
+
+- Expanded Outlook calendar sync behavior, including broader sync windows and fixes around date/time handling.
+- Improved Gmail drafting and mail/calendar integration so event-related actions work better across providers.
+- Added mail and calendar synchronizer state tracking to make sync progress and error handling more reliable.
+- Added auto calendar sync on account creation and broader auto-sync trigger and cancellation support.
+
+### Calendar polish and reliability
+
+- Fixed calendar crashes and null-handling issues in calendar view date range updates.
+- Fixed double initialization in calendar day views.
+- Improved reaction to calendar changes and calendar item update-source handling.
+- Added reminder snooze support across toast UI, services, and database storage.
+
+Overall, Wino Calendar is one of the biggest themes of this branch: richer UI, more complete event workflows, and real sync support across local, CalDAV, Outlook, and Gmail-backed scenarios.
+
+## Wino Accounts
+
+Wino Accounts was significantly expanded and polished on this branch.
+
+### Account flows and identity
+
+- Added sign in, sign out, and registration flows.
+- Redesigned login and registration dialogs.
+- Added privacy policy presentation during registration.
+- Added forgot password and email confirmation flows.
+- Pointed the app to the real API and improved profile caching.
+
+### Account management and settings
+
+- Added Wino account settings and a dedicated management page.
+- Added a special navigation item for Wino Accounts.
+- Added import functionality for Wino Accounts.
+- Added a preference to hide the title bar Wino account button.
+- Improved the top-shell account icon and signed-out identity visuals.
+
+### Purchases and add-ons
+
+- Added handling for Paddle purchases and add-ons.
+- Added purchase-success deep linking.
+- Added support for AI pack handling through the Microsoft Store.
+
+### User-facing polish
+
+- Redesigned the Wino Account flyout and menu with a more polished Fluent-style presentation.
+- Improved account cleanup behavior when an account is deleted.
+- Added account attention handling and better account details/settings behavior.
+
+Compared to `main`, this branch turns Wino Accounts into a much more complete platform feature rather than a minimal sign-in surface.
+
+## Improved Stability and Reliability
+
+A large part of this branch is about making the app more dependable in everyday use.
+
+### Synchronization stability
+
+- Refactored synchronizers to address long-standing reliability issues.
+- Improved thread mapping across synchronizers.
+- Added generic 404 handling for synchronizers.
+- Added specific Outlook 429 handling for rate-limit scenarios.
+- Improved Outlook authentication and Outlook sync reliability.
+- Improved Gmail synchronizer behavior.
+- Added explicit mail and calendar synchronizer state support.
+
+### Mail and data reliability
+
+- Optimized mail fetching with batched database queries and in-memory caching.
+- Added SQLite indexes and enabled foreign key enforcement.
+- Switched away from the old mail item queue approach and returned to a simpler initial sync strategy.
+- Improved local draft resend behavior and added grace-period handling for local drafts.
+- Added better handling for large Outlook attachments via upload sessions.
+- Fixed issues with sent/draft placement, loading mails with infinite scroll, selection cleanup, and deleted-object scenarios.
+
+### UI and lifecycle stability
+
+- Fixed mail rendering page disposal issues.
+- Fixed WebView2 runtime toast dispatching on the UI thread.
+- Fixed startup mode issues, single-instancing problems, and shell/navigation regressions.
+- Fixed multiple thread selection, container, flicker, and context-menu issues.
+- Fixed crashes and null-reference style issues in several calendar and shell flows.
+
+### Engineering quality
+
+- Added more tests across calendar, CalDAV, IMAP, view-model, sanitization, and account sync scenarios.
+- Added a GitHub Actions workflow to build WinUI and run Core tests on pull requests.
+- Resolved warnings and moved the WinUI project toward warnings-as-errors discipline.
+- Added AOT compatibility work and related cleanup across the app.
+
+The branch is not just adding features; it is also clearly reducing failure points throughout sync, rendering, navigation, and storage.
+
+## Contacts, Settings, and General UX
+
+This branch also improves the everyday product experience outside mail and calendar core flows.
+
+### Contacts
+
+- Added contacts management.
+- Improved contacts UI and related thread/image preview behavior.
+- Removed legacy SQLite base64 contact storage from `AccountContact`.
+- Added contact picture handling support and supporting contact service improvements.
+
+### Settings
+
+- Added a dedicated settings shell and refactored settings home/navigation.
+- Expanded settings UI and introduced new setting options.
+- Added calendar settings into the settings experience.
+- Improved account details/settings pages and storage settings navigation.
+- Refined settings visuals, shell integration, and menu behavior.
+
+### Onboarding and app experience
+
+- Added a new startup window and a more guided onboarding flow with wizard-like steps.
+- Added a "What's New" implementation for feature communication.
+- Improved dialogs, title bar behavior, shell content, navigation, and shell polish across multiple iterations.
+- Added live store update notifications.
+- Improved keyboard shortcuts and related dialogs.
+- Added tray icon support and better toast routing between mail and calendar app entries.
+
+## Summary
+
+Compared to `main`, `feature/vNext` delivers four major leaps:
+
+1. Wino Calendar becomes a substantially more complete feature set, including local calendar support, CalDAV sync, and stronger Outlook and Gmail calendar integration.
+2. Wino Accounts becomes a real product surface with better authentication flows, management, imports, purchases, and polish.
+3. The app is more stable thanks to synchronization refactors, storage improvements, test expansion, and many crash and lifecycle fixes.
+4. Contacts, settings, onboarding, and shell/navigation experience all feel more mature and more consistent.
+
+In short, this branch is a broad product maturation release rather than a narrow feature drop.

Settings.XamlStyler

@@ -0,0 +1,42 @@
+{
+    "AttributesTolerance": 2,
+    "KeepFirstAttributeOnSameLine": false,
+    "MaxAttributeCharactersPerLine": 0,
+    "MaxAttributesPerLine": 1,
+    "NewlineExemptionElements": "RadialGradientBrush, GradientStop, LinearGradientBrush, ScaleTransform, SkewTransform, RotateTransform, TranslateTransform, Trigger, Condition, Setter",
+    "SeparateByGroups": false,
+    "AttributeIndentation": 0,
+    "AttributeIndentationStyle": 1,
+    "RemoveDesignTimeReferences":  false,
+    "IgnoreDesignTimeReferencePrefix": false,
+    "EnableAttributeReordering": true,
+    "AttributeOrderingRuleGroups": [
+        "x:Class",
+        "xmlns, xmlns:x",
+        "xmlns:*",
+        "x:Key, Key, x:Name, Name, x:Uid, Uid, Title",
+        "Grid.Row, Grid.RowSpan, Grid.Column, Grid.ColumnSpan, Canvas.Left, Canvas.Top, Canvas.Right, Canvas.Bottom",
+        "Width, Height, MinWidth, MinHeight, MaxWidth, MaxHeight",
+        "Margin, Padding, HorizontalAlignment, VerticalAlignment, HorizontalContentAlignment, VerticalContentAlignment, Panel.ZIndex",
+        "*:*, *",
+        "PageSource, PageIndex, Offset, Color, TargetName, Property, Value, StartPoint, EndPoint",
+        "mc:Ignorable, d:IsDataSource, d:LayoutOverrides, d:IsStaticText",
+        "Storyboard.*, From, To, Duration"
+    ],
+    "FirstLineAttributes": "",
+    "OrderAttributesByName": true,
+    "PutEndingBracketOnNewLine": false,
+    "RemoveEndingTagOfEmptyElement": true,
+    "SpaceBeforeClosingSlash": true,
+    "RootElementLineBreakRule": 0,
+    "ReorderVSM": 2,
+    "ReorderGridChildren": false,
+    "ReorderCanvasChildren": false,
+    "ReorderSetters": 0,
+    "FormatMarkupExtension": true,
+    "NoNewLineMarkupExtensions": "x:Bind, Binding",
+    "ThicknessSeparator": 2,
+    "ThicknessAttributes": "Margin, Padding, BorderThickness, ThumbnailClipMargin",
+    "FormatOnSave": true,
+    "CommentPadding": 2,
+}

Wino.Authentication/BaseAuthenticator.cs

@@ -0,0 +1,16 @@
+using Wino.Core.Domain.Enums;
+using Wino.Core.Domain.Interfaces;
+
+namespace Wino.Authentication;
+
+public abstract class BaseAuthenticator
+{
+    public abstract MailProviderType ProviderType { get; }
+    protected IAuthenticatorConfig AuthenticatorConfig { get; }
+
+    protected BaseAuthenticator(IAuthenticatorConfig authenticatorConfig)
+    {
+
+        AuthenticatorConfig = authenticatorConfig;
+    }
+}

Wino.Authentication/GmailAuthenticator.cs

@@ -0,0 +1,50 @@
+using System.Threading;
+using System.Threading.Tasks;
+using Google.Apis.Auth.OAuth2;
+using Google.Apis.Util.Store;
+using Wino.Core.Domain.Entities.Shared;
+using Wino.Core.Domain.Enums;
+using Wino.Core.Domain.Interfaces;
+using Wino.Core.Domain.Models.Authentication;
+
+namespace Wino.Authentication;
+
+public class GmailAuthenticator : BaseAuthenticator, IGmailAuthenticator
+{
+    public GmailAuthenticator(IAuthenticatorConfig authConfig) : base(authConfig)
+    {
+    }
+
+    public string ClientId => AuthenticatorConfig.GmailAuthenticatorClientId;
+    public bool ProposeCopyAuthURL { get; set; }
+
+    public override MailProviderType ProviderType => MailProviderType.Gmail;
+
+    /// <summary>
+    /// Generates the token information for the given account.
+    /// For gmail, interactivity is automatically handled when you get the token.
+    /// </summary>
+    /// <param name="account">Account to get token for.</param>
+    public Task<TokenInformationEx> GenerateTokenInformationAsync(MailAccount account)
+        => GetTokenInformationAsync(account);
+
+    public async Task<TokenInformationEx> GetTokenInformationAsync(MailAccount account)
+    {
+        var userCredential = await GetGoogleUserCredentialAsync(account);
+
+        if (userCredential.Token.IsStale)
+        {
+            await userCredential.RefreshTokenAsync(CancellationToken.None);
+        }
+
+        return new TokenInformationEx(userCredential.Token.AccessToken, account.Address);
+    }
+
+    private Task<UserCredential> GetGoogleUserCredentialAsync(MailAccount account)
+    {
+        return GoogleWebAuthorizationBroker.AuthorizeAsync(new ClientSecrets()
+        {
+            ClientId = ClientId
+        }, AuthenticatorConfig.GetGmailScope(account?.IsMailAccessGranted != false, account?.IsCalendarAccessGranted == true), account.Id.ToString(), CancellationToken.None, new FileDataStore(AuthenticatorConfig.GmailTokenStoreIdentifier));
+    }
+}

Wino.Authentication/OutlookAuthenticator.cs

@@ -0,0 +1,152 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.Identity.Client;
+using Microsoft.Identity.Client.Broker;
+using Microsoft.Identity.Client.Extensions.Msal;
+using Wino.Core.Domain;
+using Wino.Core.Domain.Entities.Shared;
+using Wino.Core.Domain.Enums;
+using Wino.Core.Domain.Exceptions;
+using Wino.Core.Domain.Interfaces;
+using Wino.Core.Domain.Models.Authentication;
+
+namespace Wino.Authentication;
+
+public class OutlookAuthenticator : BaseAuthenticator, IOutlookAuthenticator
+{
+    private const string TokenCacheFileName = "OutlookCache.bin";
+    private bool isTokenCacheAttached = false;
+
+    // Outlook
+    private const string Authority = "https://login.microsoftonline.com/common";
+
+    public override MailProviderType ProviderType => MailProviderType.Outlook;
+
+    private readonly IPublicClientApplication _publicClientApplication;
+    private readonly INativeAppService _nativeAppService;
+    private readonly IApplicationConfiguration _applicationConfiguration;
+
+    public OutlookAuthenticator(INativeAppService nativeAppService,
+                                IApplicationConfiguration applicationConfiguration,
+                                IAuthenticatorConfig authenticatorConfig) : base(authenticatorConfig)
+    {
+        _nativeAppService = nativeAppService;
+        _applicationConfiguration = applicationConfiguration;
+
+        var authenticationRedirectUri = nativeAppService.GetWebAuthenticationBrokerUri();
+
+        var options = new BrokerOptions(BrokerOptions.OperatingSystems.Windows)
+        {
+            Title = "Wino Mail",
+            ListOperatingSystemAccounts = true,
+        };
+
+        PublicClientApplicationBuilder outlookAppBuilder = null;
+
+        // Being created from an app notification.
+        // This is where we avoid all interactive shit for authentication.
+        if (nativeAppService.GetCoreWindowHwnd == null)
+        {
+            outlookAppBuilder = PublicClientApplicationBuilder.Create(AuthenticatorConfig.OutlookAuthenticatorClientId)
+                .WithDefaultRedirectUri()
+                .WithBroker(options)
+                .WithAuthority(Authority);
+        }
+        else
+        {
+            outlookAppBuilder = PublicClientApplicationBuilder.Create(AuthenticatorConfig.OutlookAuthenticatorClientId)
+                .WithBroker(options)
+                .WithParentActivityOrWindow(_nativeAppService.GetCoreWindowHwnd)
+                .WithDefaultRedirectUri()
+                .WithAuthority(Authority);
+        }
+
+        _publicClientApplication = outlookAppBuilder.Build();
+    }
+
+    private string[] GetScope(MailAccount account)
+        => AuthenticatorConfig.GetOutlookScope(
+            account?.IsMailAccessGranted != false,
+            account?.IsCalendarAccessGranted == true);
+
+    private async Task EnsureTokenCacheAttachedAsync()
+    {
+        if (!isTokenCacheAttached)
+        {
+            var storageProperties = new StorageCreationPropertiesBuilder(TokenCacheFileName, _applicationConfiguration.PublisherSharedFolderPath).Build();
+            var msalcachehelper = await MsalCacheHelper.CreateAsync(storageProperties);
+            msalcachehelper.RegisterCache(_publicClientApplication.UserTokenCache);
+
+            isTokenCacheAttached = true;
+        }
+    }
+
+    public async Task<TokenInformationEx> GetTokenInformationAsync(MailAccount account)
+    {
+        await EnsureTokenCacheAttachedAsync();
+
+        var storedAccount = (await _publicClientApplication.GetAccountsAsync()).FirstOrDefault(
+            a => string.Equals(a.Username?.Trim(), account.Address?.Trim(), StringComparison.OrdinalIgnoreCase));
+
+        if (storedAccount == null)
+            return await GenerateTokenInformationAsync(account);
+
+        try
+        {
+            var authResult = await _publicClientApplication.AcquireTokenSilent(GetScope(account), storedAccount).ExecuteAsync();
+
+            return new TokenInformationEx(authResult.AccessToken, authResult.Account.Username);
+        }
+        catch (MsalUiRequiredException)
+        {
+            // Somehow MSAL is not able to refresh the token silently.
+            // Force interactive login which will include calendar scopes.
+            // The calling code should update account.IsCalendarAccessGranted = true after successful authentication.
+
+            return await GenerateTokenInformationAsync(account);
+        }
+        catch (Exception)
+        {
+            throw;
+        }
+    }
+
+    public async Task<TokenInformationEx> GenerateTokenInformationAsync(MailAccount account)
+    {
+        try
+        {
+            await EnsureTokenCacheAttachedAsync();
+
+            // Interactive authentication required but window doesn't exist.
+            // This can happen when being called from a notification background task and the token is expired.
+            // Force account attention;
+
+            if (_nativeAppService.GetCoreWindowHwnd == null) throw new AuthenticationAttentionException(account);
+
+            AuthenticationResult authResult = await _publicClientApplication
+                .AcquireTokenInteractive(GetScope(account))
+                .ExecuteAsync();
+
+            // If the account is null, it means it's the initial creation of it.
+            // If not, make sure the authenticated user address matches the username.
+            // When people refresh their token, accounts must match.
+
+            if (account?.Address != null && !account.Address.Equals(authResult.Account.Username, StringComparison.OrdinalIgnoreCase))
+            {
+                throw new AuthenticationException("Authenticated address does not match with your account address. If you are signing with a Office365, it is not officially supported yet.");
+            }
+
+            return new TokenInformationEx(authResult.AccessToken, authResult.Account.Username);
+        }
+        catch (MsalClientException msalClientException)
+        {
+            if (msalClientException.ErrorCode == "authentication_canceled" || msalClientException.ErrorCode == "access_denied")
+                throw new AccountSetupCanceledException();
+
+            throw;
+        }
+
+        throw new AuthenticationException(Translator.Exception_UnknowErrorDuringAuthentication, new Exception(Translator.Exception_TokenGenerationFailed));
+    }
+}

Wino.Authentication/Wino.Authentication.csproj

@@ -0,0 +1,26 @@
+<Project Sdk="Microsoft.NET.Sdk">
+	<PropertyGroup>
+		<TargetFramework>net10.0</TargetFramework>
+		<RuntimeIdentifiers>win-x86;win-x64;win-arm64</RuntimeIdentifiers>
+		<RootNamespace>Wino.Authentication</RootNamespace>
+		<Platforms>x86;x64;arm64</Platforms>
+		<AccelerateBuildsInVisualStudio>true</AccelerateBuildsInVisualStudio>
+		<ProduceReferenceAssembly>true</ProduceReferenceAssembly>
+		<IsTrimmable>true</IsTrimmable>
+		<EnableTrimAnalyzer>true</EnableTrimAnalyzer>
+		<TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+	</PropertyGroup>
+	<ItemGroup>
+		<PackageReference Include="CommunityToolkit.Diagnostics" />
+		<PackageReference Include="CommunityToolkit.Mvvm" />
+		<PackageReference Include="Google.Apis.Auth" />
+		<PackageReference Include="Microsoft.Identity.Client" />
+		<PackageReference Include="Microsoft.Identity.Client.Broker" />
+		<PackageReference Include="Microsoft.Identity.Client.Extensions.Msal" />
+		<PackageReference Include="Sentry.Serilog" />
+	</ItemGroup>
+	<ItemGroup>
+		<ProjectReference Include="..\Wino.Core.Domain\Wino.Core.Domain.csproj" />
+		<ProjectReference Include="..\Wino.Messages\Wino.Messaging.csproj" />
+	</ItemGroup>
+</Project>

Wino.BackgroundTasks/AppUpdatedTask.cs

@@ -1,34 +0,0 @@
-using Microsoft.Toolkit.Uwp.Notifications;
-using Windows.ApplicationModel;
-using Windows.ApplicationModel.Background;
-
-namespace Wino.BackgroundTasks
-{
-    /// <summary>
-    /// Creates a toast notification to notify user when the Store update happens.
-    /// </summary>
-    public sealed class AppUpdatedTask : IBackgroundTask
-    {
-        public void Run(IBackgroundTaskInstance taskInstance)
-        {
-            var def = taskInstance.GetDeferral();
-
-            var builder = new ToastContentBuilder();
-            builder.SetToastScenario(ToastScenario.Default);
-
-            Package package = Package.Current;
-            PackageId packageId = package.Id;
-            PackageVersion version = packageId.Version;
-
-            var versionText = string.Format("{0}.{1}.{2}.{3}", version.Major, version.Minor, version.Build, version.Revision);
-
-            // TODO: Handle with Translator, but it's not initialized here yet.
-            builder.AddText("Wino Mail is updated!");
-            builder.AddText(string.Format("New version {0} is ready.", versionText));
-
-            builder.Show();
-
-            def.Complete();
-        }
-    }
-}

Wino.BackgroundTasks/Properties/AssemblyInfo.cs

@@ -1,29 +0,0 @@
-using System.Reflection;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-// General Information about an assembly is controlled through the following 
-// set of attributes. Change these attribute values to modify the information
-// associated with an assembly.
-[assembly: AssemblyTitle("Wino.BackgroundTasks")]
-[assembly: AssemblyDescription("")]
-[assembly: AssemblyConfiguration("")]
-[assembly: AssemblyCompany("")]
-[assembly: AssemblyProduct("Wino.BackgroundTasks")]
-[assembly: AssemblyCopyright("Copyright ©  2023")]
-[assembly: AssemblyTrademark("")]
-[assembly: AssemblyCulture("")]
-
-// Version information for an assembly consists of the following four values:
-//
-//      Major Version
-//      Minor Version 
-//      Build Number
-//      Revision
-//
-// You can specify all the values or you can default the Build and Revision Numbers 
-// by using the '*' as shown below:
-// [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]
-[assembly: ComVisible(false)]

Wino.BackgroundTasks/SessionConnectedTask.cs

@@ -1,19 +0,0 @@
-using System;
-using Windows.ApplicationModel;
-using Windows.ApplicationModel.Background;
-
-namespace Wino.BackgroundTasks
-{
-    public sealed class SessionConnectedTask : IBackgroundTask
-    {
-        public async void Run(IBackgroundTaskInstance taskInstance)
-        {
-            var def = taskInstance.GetDeferral();
-
-            // Run server on session connected by launching the Full Thrust process.
-            await FullTrustProcessLauncher.LaunchFullTrustProcessForCurrentAppAsync();
-
-            def.Complete();
-        }
-    }
-}

Wino.BackgroundTasks/Wino.BackgroundTasks.csproj

@@ -1,147 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectGuid>{D9EF0F59-F5F2-4D6C-A5BA-84043D8F3E08}</ProjectGuid>
-    <OutputType>winmdobj</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>Wino.BackgroundTasks</RootNamespace>
-    <AssemblyName>Wino.BackgroundTasks</AssemblyName>
-    <DefaultLanguage>en-US</DefaultLanguage>
-    <TargetPlatformIdentifier>UAP</TargetPlatformIdentifier>
-    <TargetPlatformVersion Condition=" '$(TargetPlatformVersion)' == '' ">10.0.22621.0</TargetPlatformVersion>
-    <TargetPlatformMinVersion>10.0.17763.0</TargetPlatformMinVersion>
-    <MinimumVisualStudioVersion>14</MinimumVisualStudioVersion>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{A5A43C5B-DE2A-4C0C-9213-0A381AF9435A};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <AllowCrossPlatformRetargeting>false</AllowCrossPlatformRetargeting>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
-    <PlatformTarget>x86</PlatformTarget>
-    <DebugSymbols>true</DebugSymbols>
-    <OutputPath>bin\x86\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
-    <NoWarn>;2008</NoWarn>
-    <DebugType>full</DebugType>
-    <UseVSHostingProcess>false</UseVSHostingProcess>
-    <ErrorReport>prompt</ErrorReport>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x86'">
-    <PlatformTarget>x86</PlatformTarget>
-    <OutputPath>bin\x86\Release\</OutputPath>
-    <DefineConstants>TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
-    <Optimize>true</Optimize>
-    <NoWarn>;2008</NoWarn>
-    <DebugType>pdbonly</DebugType>
-    <UseVSHostingProcess>false</UseVSHostingProcess>
-    <ErrorReport>prompt</ErrorReport>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|ARM'">
-    <PlatformTarget>ARM</PlatformTarget>
-    <DebugSymbols>true</DebugSymbols>
-    <OutputPath>bin\ARM\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
-    <NoWarn>;2008</NoWarn>
-    <DebugType>full</DebugType>
-    <UseVSHostingProcess>false</UseVSHostingProcess>
-    <ErrorReport>prompt</ErrorReport>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|ARM'">
-    <PlatformTarget>ARM</PlatformTarget>
-    <OutputPath>bin\ARM\Release\</OutputPath>
-    <DefineConstants>TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
-    <Optimize>true</Optimize>
-    <NoWarn>;2008</NoWarn>
-    <DebugType>pdbonly</DebugType>
-    <UseVSHostingProcess>false</UseVSHostingProcess>
-    <ErrorReport>prompt</ErrorReport>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|ARM64'">
-    <PlatformTarget>ARM64</PlatformTarget>
-    <DebugSymbols>true</DebugSymbols>
-    <OutputPath>bin\ARM64\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
-    <NoWarn>;2008</NoWarn>
-    <DebugType>full</DebugType>
-    <UseVSHostingProcess>false</UseVSHostingProcess>
-    <ErrorReport>prompt</ErrorReport>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|ARM64'">
-    <PlatformTarget>ARM64</PlatformTarget>
-    <OutputPath>bin\ARM64\Release\</OutputPath>
-    <DefineConstants>TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
-    <Optimize>true</Optimize>
-    <NoWarn>;2008</NoWarn>
-    <DebugType>pdbonly</DebugType>
-    <UseVSHostingProcess>false</UseVSHostingProcess>
-    <ErrorReport>prompt</ErrorReport>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
-    <PlatformTarget>x64</PlatformTarget>
-    <DebugSymbols>true</DebugSymbols>
-    <OutputPath>bin\x64\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
-    <NoWarn>;2008</NoWarn>
-    <DebugType>full</DebugType>
-    <UseVSHostingProcess>false</UseVSHostingProcess>
-    <ErrorReport>prompt</ErrorReport>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
-    <PlatformTarget>x64</PlatformTarget>
-    <OutputPath>bin\x64\Release\</OutputPath>
-    <DefineConstants>TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
-    <Optimize>true</Optimize>
-    <NoWarn>;2008</NoWarn>
-    <DebugType>pdbonly</DebugType>
-    <UseVSHostingProcess>false</UseVSHostingProcess>
-    <ErrorReport>prompt</ErrorReport>
-  </PropertyGroup>
-  <PropertyGroup>
-    <RestoreProjectStyle>PackageReference</RestoreProjectStyle>
-  </PropertyGroup>
-  <ItemGroup>
-    <Compile Include="AppUpdatedTask.cs" />
-    <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="SessionConnectedTask.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <PackageReference Include="Microsoft.NETCore.UniversalWindowsPlatform">
-      <Version>6.2.14</Version>
-    </PackageReference>
-    <PackageReference Include="Microsoft.Toolkit.Uwp.Notifications">
-      <Version>7.1.3</Version>
-    </PackageReference>
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\Wino.Core.Domain\Wino.Core.Domain.csproj">
-      <Project>{CF3312E5-5DA0-4867-9945-49EA7598AF1F}</Project>
-      <Name>Wino.Core.Domain</Name>
-    </ProjectReference>
-    <ProjectReference Include="..\Wino.Core.UWP\Wino.Core.UWP.csproj">
-      <Project>{395f19ba-1e42-495c-9db5-1a6f537fccb8}</Project>
-      <Name>Wino.Core.UWP</Name>
-    </ProjectReference>
-    <ProjectReference Include="..\Wino.Core\Wino.Core.csproj">
-      <Project>{e6b1632a-8901-41e8-9ddf-6793c7698b0b}</Project>
-      <Name>Wino.Core</Name>
-    </ProjectReference>
-  </ItemGroup>
-  <ItemGroup>
-    <SDKReference Include="WindowsDesktop, Version=10.0.22621.0">
-      <Name>Windows Desktop Extensions for the UWP</Name>
-    </SDKReference>
-  </ItemGroup>
-  <PropertyGroup Condition=" '$(VisualStudioVersion)' == '' or '$(VisualStudioVersion)' &lt; '14.0' ">
-    <VisualStudioVersion>14.0</VisualStudioVersion>
-  </PropertyGroup>
-  <Import Project="$(MSBuildExtensionsPath)\Microsoft\WindowsXaml\v$(VisualStudioVersion)\Microsoft.Windows.UI.Xaml.CSharp.targets" />
-  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
-       Other similar extension points exist, see Microsoft.Common.targets.
-  <Target Name="BeforeBuild">
-  </Target>
-  <Target Name="AfterBuild">
-  </Target>
-  -->
-</Project>

Wino.Calendar.ViewModels/CalendarAccountSettingsPageViewModel.cs

@@ -0,0 +1,123 @@
+using System;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Threading.Tasks;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Messaging;
+using Wino.Core.Domain;
+using Wino.Core.Domain.Entities.Calendar;
+using Wino.Core.Domain.Entities.Shared;
+using Wino.Core.Domain.Enums;
+using Wino.Core.Domain.Interfaces;
+using Wino.Core.Domain.Models.Navigation;
+using Wino.Core.ViewModels;
+using Wino.Messaging.Client.Calendar;
+
+namespace Wino.Calendar.ViewModels;
+
+/// <summary>
+/// ViewModel for managing calendar account settings.
+/// </summary>
+public partial class CalendarAccountSettingsPageViewModel : CalendarBaseViewModel
+{
+    private readonly ICalendarService _calendarService;
+    private readonly IAccountService _accountService;
+    
+    [ObservableProperty]
+    public partial MailAccount Account { get; set; }
+
+    [ObservableProperty]
+    public partial AccountCalendar AccountCalendar { get; set; }
+
+    [ObservableProperty]
+    public partial string AccountColorHex { get; set; } = "#0078D4";
+
+    [ObservableProperty]
+    public partial bool IsSyncEnabled { get; set; }
+
+    public ObservableCollection<ShowAsOption> ShowAsOptions { get; } = new ObservableCollection<ShowAsOption>();
+
+    [ObservableProperty]
+    public partial ShowAsOption SelectedDefaultShowAsOption { get; set; }
+
+    public CalendarAccountSettingsPageViewModel(ICalendarService calendarService, IAccountService accountService)
+    {
+        _calendarService = calendarService;
+        _accountService = accountService;
+
+        // Initialize ShowAs options
+        ShowAsOptions.Add(new ShowAsOption(CalendarItemShowAs.Free));
+        ShowAsOptions.Add(new ShowAsOption(CalendarItemShowAs.Tentative));
+        ShowAsOptions.Add(new ShowAsOption(CalendarItemShowAs.Busy));
+        ShowAsOptions.Add(new ShowAsOption(CalendarItemShowAs.OutOfOffice));
+        ShowAsOptions.Add(new ShowAsOption(CalendarItemShowAs.WorkingElsewhere));
+    }
+
+    public override async void OnNavigatedTo(NavigationMode mode, object parameters)
+    {
+        base.OnNavigatedTo(mode, parameters);
+
+        if (parameters is AccountCalendar selectedCalendar)
+        {
+            Account = await _accountService.GetAccountAsync(selectedCalendar.AccountId);
+            AccountCalendar = await _calendarService.GetAccountCalendarAsync(selectedCalendar.Id) ?? selectedCalendar;
+        }
+        else if (parameters is Guid accountId)
+        {
+            Account = await _accountService.GetAccountAsync(accountId);
+            var calendars = await _calendarService.GetAccountCalendarsAsync(accountId);
+            AccountCalendar = calendars.FirstOrDefault(c => c.IsPrimary) ?? calendars.FirstOrDefault();
+        }
+        else
+        {
+            return;
+        }
+
+        if (Account == null || AccountCalendar == null)
+            return;
+
+        // Initialize properties from AccountCalendar
+        AccountColorHex = AccountCalendar.BackgroundColorHex ?? "#0078D4";
+        IsSyncEnabled = AccountCalendar.IsSynchronizationEnabled;
+        SelectedDefaultShowAsOption = ShowAsOptions.FirstOrDefault(o => o.ShowAs == AccountCalendar.DefaultShowAs) ?? ShowAsOptions[2];
+    }
+
+    partial void OnAccountColorHexChanged(string value)
+    {
+        if (AccountCalendar != null && !string.IsNullOrEmpty(value))
+        {
+            AccountCalendar.BackgroundColorHex = value;
+            AccountCalendar.IsBackgroundColorUserOverridden = true;
+            SaveChangesAsync();
+        }
+    }
+
+    partial void OnIsSyncEnabledChanged(bool value)
+    {
+        if (AccountCalendar != null)
+        {
+            AccountCalendar.IsSynchronizationEnabled = value;
+            SaveChangesAsync();
+        }
+    }
+
+    partial void OnSelectedDefaultShowAsOptionChanged(ShowAsOption value)
+    {
+        if (AccountCalendar != null && value != null)
+        {
+            AccountCalendar.DefaultShowAs = value.ShowAs;
+            SaveChangesAsync();
+        }
+    }
+
+    private async void SaveChangesAsync()
+    {
+        if (AccountCalendar == null)
+            return;
+
+        await _calendarService.UpdateAccountCalendarAsync(AccountCalendar);
+        
+        // Send message to update UI
+        Messenger.Send(new CalendarListUpdated(AccountCalendar));
+    }
+}

Wino.Calendar.ViewModels/CalendarAppShellViewModel.cs

@@ -0,0 +1,562 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Globalization;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using CommunityToolkit.Mvvm.Messaging;
+using Serilog;
+using Wino.Calendar.ViewModels.Data;
+using Wino.Calendar.ViewModels.Interfaces;
+using Wino.Core.Domain;
+using Wino.Core.Domain.Collections;
+using Wino.Core.Domain.Entities.Calendar;
+using Wino.Core.Domain.Enums;
+using Wino.Core.Domain.Interfaces;
+using Wino.Core.Domain.MenuItems;
+using Wino.Core.Domain.Models;
+using Wino.Core.Domain.Models.Calendar;
+using Wino.Core.Domain.Models.Navigation;
+using Wino.Core.Domain.Models.Synchronization;
+using Wino.Core.ViewModels;
+using Wino.Messaging.Client.Calendar;
+using Wino.Messaging.Server;
+using Wino.Messaging.UI;
+
+namespace Wino.Calendar.ViewModels;
+
+public partial class CalendarAppShellViewModel : CalendarBaseViewModel,
+    ICalendarShellClient,
+    IRecipient<CalendarDisplayTypeChangedMessage>,
+    IRecipient<AccountRemovedMessage>
+{
+    public IPreferencesService PreferencesService { get; }
+    public IStatePersistanceService StatePersistenceService { get; }
+    public IAccountCalendarStateService AccountCalendarStateService { get; }
+    public INavigationService NavigationService { get; }
+    public WinoApplicationMode Mode => WinoApplicationMode.Calendar;
+    public bool HandlesNavigationSelection => false;
+    public VisibleDateRange CurrentVisibleRange => _calendarPageViewModel.CurrentVisibleRange;
+    public string VisibleDateRangeText => _calendarPageViewModel.VisibleDateRangeText;
+    System.Collections.IEnumerable ICalendarShellClient.GroupedAccountCalendars => AccountCalendarStateService.GroupedAccountCalendars;
+    System.Collections.IEnumerable ICalendarShellClient.DateNavigationHeaderItems => DateNavigationHeaderItems;
+    object IShellClient.SelectedMenuItem
+    {
+        get => null;
+        set { }
+    }
+    System.Windows.Input.ICommand ICalendarShellClient.TodayClickedCommand => TodayClickedCommand;
+    System.Windows.Input.ICommand ICalendarShellClient.DateClickedCommand => DateClickedCommand;
+    System.Windows.Input.ICommand ICalendarShellClient.PreviousDateRangeCommand => PreviousDateRangeCommand;
+    System.Windows.Input.ICommand ICalendarShellClient.NextDateRangeCommand => NextDateRangeCommand;
+    System.Windows.Input.ICommand ICalendarShellClient.SyncCommand => SyncCommand;
+
+    public bool CanSynchronizeCalendars => !AccountCalendarStateService.IsAnySynchronizationInProgress;
+
+    public MenuItemCollection MenuItems { get; private set; }
+    public MenuItemCollection FooterItems { get; private set; }
+
+    [ObservableProperty]
+    private int _selectedMenuItemIndex = -1;
+
+    [ObservableProperty]
+    private ObservableRangeCollection<string> dateNavigationHeaderItems = [];
+
+    [ObservableProperty]
+    private int _selectedDateNavigationHeaderIndex;
+
+    public bool IsVerticalCalendar => StatePersistenceService.CalendarDisplayType == CalendarDisplayType.Month;
+
+    [ObservableProperty]
+    private bool isStoreUpdateItemVisible;
+
+    private readonly SettingsItem _settingsItem = new();
+    private readonly StoreUpdateMenuItem _storeUpdateMenuItem = new();
+    private readonly SemaphoreSlim _accountCalendarUpdateSemaphoreSlim = new(1);
+    private readonly CalendarPageViewModel _calendarPageViewModel;
+    private readonly IMailDialogService _dialogService;
+    private readonly IStoreUpdateService _storeUpdateService;
+    private readonly IAccountService _accountService;
+    private readonly ICalendarService _calendarService;
+    private readonly IDateContextProvider _dateContextProvider;
+    private bool _runtimeSubscriptionsAttached;
+    private bool _hasRegisteredPersistentRecipients;
+    private DateTime? _navigationDate;
+
+    public CalendarAppShellViewModel(
+        IPreferencesService preferencesService,
+        IStatePersistanceService statePersistanceService,
+        IAccountService accountService,
+        ICalendarService calendarService,
+        IAccountCalendarStateService accountCalendarStateService,
+        INavigationService navigationService,
+        CalendarPageViewModel calendarPageViewModel,
+        IMailDialogService dialogService,
+        IStoreUpdateService storeUpdateService,
+        IDateContextProvider dateContextProvider)
+    {
+        PreferencesService = preferencesService;
+        StatePersistenceService = statePersistanceService;
+        AccountCalendarStateService = accountCalendarStateService;
+        NavigationService = navigationService;
+        _accountService = accountService;
+        _calendarService = calendarService;
+        _calendarPageViewModel = calendarPageViewModel;
+        _dialogService = dialogService;
+        _storeUpdateService = storeUpdateService;
+        _dateContextProvider = dateContextProvider;
+
+        _calendarPageViewModel.PropertyChanged += CalendarPageViewModelPropertyChanged;
+        AccountCalendarStateService.PropertyChanged += AccountCalendarStateServicePropertyChanged;
+    }
+
+    protected override void OnDispatcherAssigned()
+    {
+        base.OnDispatcherAssigned();
+
+        AccountCalendarStateService.Dispatcher = Dispatcher;
+        MenuItems = new MenuItemCollection(Dispatcher);
+        FooterItems = new MenuItemCollection(Dispatcher);
+        _ = RefreshFooterItemsAsync(false);
+    }
+
+    private void CalendarPageViewModelPropertyChanged(object sender, PropertyChangedEventArgs e)
+    {
+        if (e.PropertyName == nameof(CalendarPageViewModel.CurrentVisibleRange))
+        {
+            OnPropertyChanged(nameof(CurrentVisibleRange));
+        }
+
+        if (e.PropertyName == nameof(CalendarPageViewModel.CurrentVisibleRange) ||
+            e.PropertyName == nameof(CalendarPageViewModel.VisibleDateRangeText))
+        {
+            OnPropertyChanged(nameof(VisibleDateRangeText));
+            UpdateDateNavigationHeaderItems();
+        }
+    }
+
+    private void PrefefencesChanged(object sender, string e)
+    {
+        if (e != nameof(StatePersistenceService.CalendarDisplayType))
+            return;
+
+        Messenger.Send(new CalendarDisplayTypeChangedMessage(StatePersistenceService.CalendarDisplayType));
+        OnPropertyChanged(nameof(IsVerticalCalendar));
+        UpdateDateNavigationHeaderItems();
+        NavigateCalendarDate(GetDisplayTypeSwitchDate());
+    }
+
+    private async void PreferencesServiceChanged(object sender, string e)
+    {
+        if (e == nameof(IPreferencesService.IsStoreUpdateNotificationsEnabled))
+        {
+            await RefreshFooterItemsAsync(false);
+        }
+    }
+
+    public override async void OnNavigatedTo(NavigationMode mode, object parameters)
+    {
+        if (!_hasRegisteredPersistentRecipients)
+        {
+            RegisterRecipients();
+            _hasRegisteredPersistentRecipients = true;
+        }
+
+        AttachRuntimeSubscriptions();
+
+        var activationContext = parameters as ShellModeActivationContext;
+        var shouldRunStartupFlows = activationContext?.IsInitialActivation ?? true;
+        var navigationArgs = activationContext?.Parameter as CalendarPageNavigationArgs;
+
+        PreferencesService.PreferenceChanged -= PreferencesServiceChanged;
+        PreferencesService.PreferenceChanged += PreferencesServiceChanged;
+
+        await RefreshFooterItemsAsync(mode == NavigationMode.New);
+        UpdateDateNavigationHeaderItems();
+        await InitializeAccountCalendarsAsync();
+        ValidateConfiguredNewEventCalendar();
+
+        if (navigationArgs != null)
+        {
+            NavigationService.Navigate(WinoPage.CalendarPage, navigationArgs);
+        }
+        else if (shouldRunStartupFlows || _calendarPageViewModel.CurrentVisibleRange == null)
+        {
+            TodayClicked();
+        }
+    }
+
+    public override void OnNavigatedFrom(NavigationMode mode, object parameters)
+    {
+        DetachRuntimeSubscriptions();
+        PreferencesService.PreferenceChanged -= PreferencesServiceChanged;
+        _ = ExecuteUIThread(() =>
+        {
+            DateNavigationHeaderItems.Clear();
+            AccountCalendarStateService.ClearGroupedAccountCalendars();
+            SelectedDateNavigationHeaderIndex = -1;
+        });
+        _calendarPageViewModel.CleanupForShellDeactivation();
+    }
+
+    public void PrepareForShellShutdown()
+    {
+        DetachRuntimeSubscriptions();
+        PreferencesService.PreferenceChanged -= PreferencesServiceChanged;
+
+        if (_hasRegisteredPersistentRecipients)
+        {
+            UnregisterRecipients();
+            _hasRegisteredPersistentRecipients = false;
+        }
+
+        DateNavigationHeaderItems.Clear();
+        SelectedDateNavigationHeaderIndex = -1;
+        SelectedMenuItemIndex = -1;
+        MenuItems?.Clear();
+        FooterItems?.Clear();
+        AccountCalendarStateService.ClearGroupedAccountCalendars();
+        _calendarPageViewModel.CleanupForShellDeactivation();
+    }
+
+    private void AccountCalendarStateServicePropertyChanged(object sender, PropertyChangedEventArgs e)
+    {
+        if (e.PropertyName != nameof(IAccountCalendarStateService.IsAnySynchronizationInProgress))
+            return;
+
+        OnPropertyChanged(nameof(CanSynchronizeCalendars));
+        SyncCommand.NotifyCanExecuteChanged();
+    }
+
+    private void AttachRuntimeSubscriptions()
+    {
+        if (_runtimeSubscriptionsAttached)
+            return;
+
+        AccountCalendarStateService.AccountCalendarSelectionStateChanged += UpdateAccountCalendarRequested;
+        AccountCalendarStateService.CollectiveAccountGroupSelectionStateChanged += AccountCalendarStateCollectivelyChanged;
+        StatePersistenceService.StatePropertyChanged += PrefefencesChanged;
+        _runtimeSubscriptionsAttached = true;
+    }
+
+    private void DetachRuntimeSubscriptions()
+    {
+        if (!_runtimeSubscriptionsAttached)
+            return;
+
+        AccountCalendarStateService.AccountCalendarSelectionStateChanged -= UpdateAccountCalendarRequested;
+        AccountCalendarStateService.CollectiveAccountGroupSelectionStateChanged -= AccountCalendarStateCollectivelyChanged;
+        StatePersistenceService.StatePropertyChanged -= PrefefencesChanged;
+        _runtimeSubscriptionsAttached = false;
+    }
+
+    private async Task RefreshFooterItemsAsync(bool showNotification)
+    {
+        await ExecuteUIThread(() =>
+        {
+            FooterItems.Clear();
+        });
+    }
+
+    private async Task StartStoreUpdateAsync()
+    {
+        await _storeUpdateService.StartUpdateAsync().ConfigureAwait(false);
+        await RefreshFooterItemsAsync(false).ConfigureAwait(false);
+    }
+
+    private async void AccountCalendarStateCollectivelyChanged(object sender, GroupedAccountCalendarViewModel e)
+    {
+        try
+        {
+            await _accountCalendarUpdateSemaphoreSlim.WaitAsync();
+
+            foreach (var calendar in e.AccountCalendars)
+            {
+                await _calendarService.UpdateAccountCalendarAsync(calendar.AccountCalendar).ConfigureAwait(false);
+            }
+        }
+        catch (Exception ex)
+        {
+            Log.Error(ex, "Error while waiting for account calendar update semaphore.");
+        }
+        finally
+        {
+            _accountCalendarUpdateSemaphoreSlim.Release();
+        }
+    }
+
+    private async void UpdateAccountCalendarRequested(object sender, AccountCalendarViewModel e)
+        => await _calendarService.UpdateAccountCalendarAsync(e.AccountCalendar).ConfigureAwait(false);
+
+    private async Task InitializeAccountCalendarsAsync()
+    {
+        await Dispatcher.ExecuteOnUIThread(() => AccountCalendarStateService.ClearGroupedAccountCalendars());
+
+        var accounts = await _accountService.GetAccountsAsync().ConfigureAwait(false);
+
+        foreach (var account in accounts)
+        {
+            if (!GroupedAccountCalendarViewModel.SupportsCalendar(account))
+                continue;
+
+            var accountCalendars = await _calendarService.GetAccountCalendarsAsync(account.Id).ConfigureAwait(false);
+            var calendarViewModels = accountCalendars.Select(calendar => new AccountCalendarViewModel(account, calendar)).ToList();
+            var groupedAccountCalendarViewModel = new GroupedAccountCalendarViewModel(account, calendarViewModels);
+
+            await Dispatcher.ExecuteOnUIThread(() =>
+            {
+                AccountCalendarStateService.AddGroupedAccountCalendar(groupedAccountCalendarViewModel);
+            });
+        }
+    }
+
+    private void NavigateCalendarDate(DateTime date)
+    {
+        _navigationDate = date.Date;
+        ForceNavigateCalendarDate();
+    }
+
+    private void ForceNavigateCalendarDate()
+    {
+        var args = new CalendarPageNavigationArgs
+        {
+            NavigationDate = _navigationDate ?? DateTime.Now.Date
+        };
+
+        NavigationService.Navigate(WinoPage.CalendarPage, args);
+        _navigationDate = null;
+    }
+
+    [RelayCommand(CanExecute = nameof(CanSynchronizeCalendars))]
+    private async Task Sync()
+    {
+        var accounts = await _accountService.GetAccountsAsync().ConfigureAwait(false);
+        foreach (var account in accounts)
+        {
+            Messenger.Send(new NewCalendarSynchronizationRequested(new CalendarSynchronizationOptions
+            {
+                AccountId = account.Id,
+                Type = CalendarSynchronizationType.Strict
+            }));
+        }
+    }
+
+    private DateTime GetDisplayTypeSwitchDate()
+    {
+        var today = _dateContextProvider.GetToday();
+        var settings = PreferencesService.GetCurrentCalendarSettings();
+        var referenceRange = CurrentVisibleRange
+                             ?? CalendarRangeResolver.Resolve(new CalendarDisplayRequest(StatePersistenceService.CalendarDisplayType, today), settings, today);
+        var targetRange = CalendarRangeResolver.ChangeDisplayType(referenceRange, StatePersistenceService.CalendarDisplayType, settings, today);
+        return targetRange.AnchorDate.ToDateTime(TimeOnly.MinValue);
+    }
+
+    [RelayCommand]
+    private void TodayClicked()
+    {
+        NavigateCalendarDate(_dateContextProvider.GetToday().ToDateTime(TimeOnly.MinValue));
+    }
+
+    [RelayCommand]
+    private void PreviousDateRange()
+    {
+        NavigateRelativePeriod(-1);
+    }
+
+    [RelayCommand]
+    private void NextDateRange()
+    {
+        NavigateRelativePeriod(1);
+    }
+
+    private void NavigateRelativePeriod(int direction)
+    {
+        var today = _dateContextProvider.GetToday();
+        var settings = PreferencesService.GetCurrentCalendarSettings();
+        var referenceRange = CurrentVisibleRange
+                             ?? CalendarRangeResolver.Resolve(new CalendarDisplayRequest(StatePersistenceService.CalendarDisplayType, today), settings, today);
+        var targetRange = CalendarRangeResolver.Navigate(referenceRange, direction, settings, today);
+        NavigateCalendarDate(targetRange.AnchorDate.ToDateTime(TimeOnly.MinValue));
+    }
+
+    public async Task HandleNavigationItemInvokedAsync(IMenuItem menuItem)
+    {
+        switch (menuItem)
+        {
+            case NewMailMenuItem:
+                await NewEventAsync().ConfigureAwait(false);
+                break;
+            case SettingsItem:
+                NavigationService.Navigate(WinoPage.SettingsPage);
+                break;
+            case StoreUpdateMenuItem:
+                await StartStoreUpdateAsync().ConfigureAwait(false);
+                break;
+        }
+    }
+
+    [RelayCommand]
+    private async Task NewEventAsync()
+    {
+        var pickedCalendar = TryResolveConfiguredNewEventCalendar();
+
+        if (pickedCalendar == null)
+        {
+            var availableGroups = AccountCalendarStateService.GroupedAccountCalendars
+                .Where(group => group.AccountCalendars.Count > 0)
+                .Select(group => new CalendarPickerAccountGroup
+                {
+                    Account = group.Account,
+                    Calendars = group.AccountCalendars.Select(calendar => calendar.AccountCalendar).ToList()
+                })
+                .ToList();
+
+            if (availableGroups.Count == 0)
+            {
+                _dialogService.InfoBarMessage(
+                    Translator.CalendarEventCompose_NoCalendarsTitle,
+                    Translator.CalendarEventCompose_NoCalendarsMessage,
+                    InfoBarMessageType.Warning);
+                return;
+            }
+
+            var pickingResult = await _dialogService.ShowSingleCalendarPickerDialogAsync(availableGroups);
+            if (pickingResult.ShouldNavigateToCalendarSettings)
+            {
+                NavigationService.Navigate(WinoPage.CalendarPreferenceSettingsPage);
+                return;
+            }
+
+            pickedCalendar = pickingResult.PickedCalendar;
+        }
+
+        if (pickedCalendar == null)
+            return;
+
+        var (startDate, endDate) = GetDefaultComposeDateRange();
+
+        NavigationService.Navigate(WinoPage.CalendarEventComposePage, new CalendarEventComposeNavigationArgs
+        {
+            SelectedCalendarId = pickedCalendar.Id,
+            StartDate = startDate,
+            EndDate = endDate
+        });
+    }
+
+    public override async Task KeyboardShortcutHook(KeyboardShortcutTriggerDetails args)
+    {
+        if (args.Handled || args.Mode != WinoApplicationMode.Calendar)
+            return;
+
+        if (args.Action == KeyboardShortcutAction.NewEvent)
+        {
+            await NewEventAsync();
+            args.Handled = true;
+        }
+    }
+
+    [RelayCommand]
+    private void DateClicked(CalendarViewDayClickedEventArgs clickedDateArgs)
+        => NavigateCalendarDate(clickedDateArgs.ClickedDate);
+
+    protected override void RegisterRecipients()
+    {
+        base.RegisterRecipients();
+
+        UnregisterRecipients();
+
+        Messenger.Register<CalendarDisplayTypeChangedMessage>(this);
+        Messenger.Register<AccountRemovedMessage>(this);
+    }
+
+    protected override void UnregisterRecipients()
+    {
+        base.UnregisterRecipients();
+
+        Messenger.Unregister<CalendarDisplayTypeChangedMessage>(this);
+        Messenger.Unregister<AccountRemovedMessage>(this);
+    }
+
+    private void UpdateDateNavigationHeaderItems()
+    {
+        var headerText = VisibleDateRangeText;
+        DateNavigationHeaderItems.ReplaceRange(string.IsNullOrWhiteSpace(headerText) ? [] : [headerText]);
+        SelectedDateNavigationHeaderIndex = DateNavigationHeaderItems.Count > 0 ? 0 : -1;
+    }
+
+    public void Receive(CalendarDisplayTypeChangedMessage message)
+    {
+        OnPropertyChanged(nameof(IsVerticalCalendar));
+        UpdateDateNavigationHeaderItems();
+    }
+
+    public async void Receive(AccountRemovedMessage message)
+    {
+        await InitializeAccountCalendarsAsync();
+        ValidateConfiguredNewEventCalendar();
+    }
+
+    private AccountCalendar TryResolveConfiguredNewEventCalendar()
+    {
+        ValidateConfiguredNewEventCalendar();
+
+        if (PreferencesService.NewEventButtonBehavior != NewEventButtonBehavior.AlwaysUseSpecificCalendar
+            || !PreferencesService.DefaultNewEventCalendarId.HasValue)
+        {
+            return null;
+        }
+
+        return AccountCalendarStateService.AllCalendars
+            .FirstOrDefault(calendar => calendar.Id == PreferencesService.DefaultNewEventCalendarId.Value)?
+            .AccountCalendar;
+    }
+
+    private void ValidateConfiguredNewEventCalendar()
+    {
+        if (PreferencesService.NewEventButtonBehavior != NewEventButtonBehavior.AlwaysUseSpecificCalendar
+            || !PreferencesService.DefaultNewEventCalendarId.HasValue)
+        {
+            return;
+        }
+
+        var exists = AccountCalendarStateService.AllCalendars
+            .Any(calendar => calendar.Id == PreferencesService.DefaultNewEventCalendarId.Value);
+
+        if (!exists)
+        {
+            PreferencesService.NewEventButtonBehavior = NewEventButtonBehavior.AskEachTime;
+            PreferencesService.DefaultNewEventCalendarId = null;
+        }
+    }
+
+    private static (DateTime StartDate, DateTime EndDate) GetDefaultComposeDateRange()
+    {
+        var localNow = DateTime.Now;
+        var roundedMinutes = localNow.Minute switch
+        {
+            < 30 => 30,
+            30 when localNow.Second == 0 && localNow.Millisecond == 0 => 30,
+            _ => 60
+        };
+
+        var startDate = new DateTime(localNow.Year, localNow.Month, localNow.Day, localNow.Hour, 0, 0);
+        startDate = roundedMinutes == 60 ? startDate.AddHours(1) : startDate.AddMinutes(roundedMinutes);
+
+        return (startDate, startDate.AddMinutes(30));
+    }
+
+    void IShellClient.Activate(ShellModeActivationContext activationContext)
+        => OnNavigatedTo(NavigationMode.New, activationContext);
+
+    void IShellClient.Deactivate()
+        => OnNavigatedFrom(NavigationMode.New, null!);
+
+    Task IShellClient.HandleNavigationItemInvokedAsync(IMenuItem menuItem)
+        => menuItem == null ? Task.CompletedTask : HandleNavigationItemInvokedAsync(menuItem);
+
+    Task IShellClient.HandleNavigationSelectionChangedAsync(IMenuItem menuItem)
+        => Task.CompletedTask;
+}

Wino.Calendar.ViewModels/CalendarEventComposePageViewModel.cs

@@ -0,0 +1,763 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using EmailValidation;
+using Wino.Calendar.ViewModels.Data;
+using Wino.Core.Domain;
+using Wino.Core.Domain.Entities.Calendar;
+using Wino.Core.Domain.Entities.Shared;
+using Wino.Core.Domain.Enums;
+using Wino.Core.Domain.Exceptions;
+using Wino.Core.Domain.Interfaces;
+using Wino.Core.Domain.Models.Calendar;
+using Wino.Core.Domain.Models.Navigation;
+using Wino.Core.Domain.Validation;
+using Wino.Core.ViewModels;
+
+namespace Wino.Calendar.ViewModels;
+
+public partial class CalendarEventComposePageViewModel : CalendarBaseViewModel
+{
+    private readonly IAccountService _accountService;
+    private readonly ICalendarService _calendarService;
+    private readonly INavigationService _navigationService;
+    private readonly IMailDialogService _dialogService;
+    private readonly IContactService _contactService;
+    private readonly IPreferencesService _preferencesService;
+    private readonly IUnderlyingThemeService _underlyingThemeService;
+    private readonly IWinoRequestDelegator _winoRequestDelegator;
+    private readonly CalendarEventComposeResultValidator _composeResultValidator = new();
+
+    public Func<Task<string>> GetHtmlNotesAsync { get; set; }
+
+    public ObservableCollection<AccountCalendarViewModel> AvailableCalendars { get; } = [];
+    public ObservableCollection<GroupedAccountCalendarViewModel> AvailableCalendarGroups { get; } = [];
+    public ObservableCollection<CalendarComposeAttendeeViewModel> Attendees { get; } = [];
+    public ObservableCollection<CalendarComposeAttachmentViewModel> Attachments { get; } = [];
+    public ObservableCollection<ShowAsOption> ShowAsOptions { get; } = [];
+    public ObservableCollection<ReminderOption> ReminderOptions { get; } = [];
+    public ObservableCollection<int> RecurrenceIntervalOptions { get; } = [];
+    public ObservableCollection<CalendarComposeFrequencyOption> RecurrenceFrequencyOptions { get; } = [];
+    public ObservableCollection<CalendarComposeWeekdayOption> WeekdayOptions { get; } = [];
+
+    [ObservableProperty]
+    public partial AccountCalendarViewModel SelectedCalendar { get; set; }
+
+    [ObservableProperty]
+    public partial string Title { get; set; } = string.Empty;
+
+    [ObservableProperty]
+    public partial string Location { get; set; } = string.Empty;
+
+    [ObservableProperty]
+    public partial bool IsAllDay { get; set; }
+
+    [ObservableProperty]
+    public partial DateTimeOffset StartDate { get; set; }
+
+    [ObservableProperty]
+    public partial TimeSpan StartTime { get; set; }
+
+    [ObservableProperty]
+    public partial TimeSpan EndTime { get; set; }
+
+    [ObservableProperty]
+    public partial DateTimeOffset AllDayEndDate { get; set; }
+
+    [ObservableProperty]
+    public partial bool IsRecurring { get; set; }
+
+    [ObservableProperty]
+    public partial int SelectedRecurrenceInterval { get; set; } = 1;
+
+    [ObservableProperty]
+    public partial CalendarComposeFrequencyOption SelectedRecurrenceFrequencyOption { get; set; }
+
+    [ObservableProperty]
+    public partial DateTimeOffset? RecurrenceEndDate { get; set; }
+
+    [ObservableProperty]
+    public partial string RecurrenceSummary { get; set; } = string.Empty;
+
+    [ObservableProperty]
+    public partial ReminderOption SelectedReminderOption { get; set; }
+
+    [ObservableProperty]
+    public partial ShowAsOption SelectedShowAsOption { get; set; }
+
+    [ObservableProperty]
+    public partial bool IsDarkWebviewRenderer { get; set; }
+
+    [ObservableProperty]
+    public partial CalendarEventComposeResult LastCreatedResult { get; set; }
+
+    public CalendarSettings CurrentSettings { get; }
+    public string TimePickerClockIdentifier => CurrentSettings.DayHeaderDisplayType == DayHeaderDisplayType.TwentyFourHour ? "24HourClock" : "12HourClock";
+    public bool HasAttachments => Attachments.Count > 0;
+    public bool IsSelectedCalendarCalDav => SelectedCalendar?.Account?.ProviderType == MailProviderType.IMAP4 &&
+                                            SelectedCalendar.Account.ServerInformation?.CalendarSupportMode == ImapCalendarSupportMode.CalDav;
+    public bool CanAddAttachments => !IsSelectedCalendarCalDav;
+    public string AttachmentsDisabledTooltipText => IsSelectedCalendarCalDav
+        ? Translator.CalendarEventCompose_AttachmentsNotSupportedForCalDav
+        : string.Empty;
+    public string SelectedCalendarDisplayText => SelectedCalendar?.Name ?? Translator.CalendarEventCompose_SelectCalendar;
+    public string SelectedCalendarAccountText => SelectedCalendar?.Account?.Address ?? string.Empty;
+    public bool IsDailyRecurrenceSelected => SelectedRecurrenceFrequencyOption?.Frequency == CalendarItemRecurrenceFrequency.Daily;
+
+    public CalendarEventComposePageViewModel(IAccountService accountService,
+                                             ICalendarService calendarService,
+                                             INavigationService navigationService,
+                                             IMailDialogService dialogService,
+                                             IContactService contactService,
+                                             IPreferencesService preferencesService,
+                                             IUnderlyingThemeService underlyingThemeService,
+                                             IWinoRequestDelegator winoRequestDelegator)
+    {
+        _accountService = accountService;
+        _calendarService = calendarService;
+        _navigationService = navigationService;
+        _dialogService = dialogService;
+        _contactService = contactService;
+        _preferencesService = preferencesService;
+        _underlyingThemeService = underlyingThemeService;
+        _winoRequestDelegator = winoRequestDelegator;
+
+        CurrentSettings = _preferencesService.GetCurrentCalendarSettings();
+        IsDarkWebviewRenderer = _underlyingThemeService.IsUnderlyingThemeDark();
+
+        Attachments.CollectionChanged += AttachmentsCollectionChanged;
+
+        ShowAsOptions.Add(new ShowAsOption(CalendarItemShowAs.Free));
+        ShowAsOptions.Add(new ShowAsOption(CalendarItemShowAs.Tentative));
+        ShowAsOptions.Add(new ShowAsOption(CalendarItemShowAs.Busy));
+        ShowAsOptions.Add(new ShowAsOption(CalendarItemShowAs.OutOfOffice));
+        ShowAsOptions.Add(new ShowAsOption(CalendarItemShowAs.WorkingElsewhere));
+
+        foreach (var reminderMinutes in _calendarService.GetPredefinedReminderMinutes().OrderByDescending(x => x))
+        {
+            ReminderOptions.Add(new ReminderOption(reminderMinutes));
+        }
+
+        foreach (var interval in Enumerable.Range(1, 99))
+        {
+            RecurrenceIntervalOptions.Add(interval);
+        }
+
+        RecurrenceFrequencyOptions.Add(new CalendarComposeFrequencyOption(CalendarItemRecurrenceFrequency.Daily, Translator.CalendarEventCompose_FrequencyDay));
+        RecurrenceFrequencyOptions.Add(new CalendarComposeFrequencyOption(CalendarItemRecurrenceFrequency.Weekly, Translator.CalendarEventCompose_FrequencyWeek));
+        RecurrenceFrequencyOptions.Add(new CalendarComposeFrequencyOption(CalendarItemRecurrenceFrequency.Monthly, Translator.CalendarEventCompose_FrequencyMonth));
+        RecurrenceFrequencyOptions.Add(new CalendarComposeFrequencyOption(CalendarItemRecurrenceFrequency.Yearly, Translator.CalendarEventCompose_FrequencyYear));
+        SelectedRecurrenceFrequencyOption = RecurrenceFrequencyOptions.FirstOrDefault();
+
+        WeekdayOptions.Add(CreateWeekdayOption(DayOfWeek.Monday, "MO", Translator.CalendarEventCompose_Weekday_Monday));
+        WeekdayOptions.Add(CreateWeekdayOption(DayOfWeek.Tuesday, "TU", Translator.CalendarEventCompose_Weekday_Tuesday));
+        WeekdayOptions.Add(CreateWeekdayOption(DayOfWeek.Wednesday, "WE", Translator.CalendarEventCompose_Weekday_Wednesday));
+        WeekdayOptions.Add(CreateWeekdayOption(DayOfWeek.Thursday, "TH", Translator.CalendarEventCompose_Weekday_Thursday));
+        WeekdayOptions.Add(CreateWeekdayOption(DayOfWeek.Friday, "FR", Translator.CalendarEventCompose_Weekday_Friday));
+        WeekdayOptions.Add(CreateWeekdayOption(DayOfWeek.Saturday, "SA", Translator.CalendarEventCompose_Weekday_Saturday));
+        WeekdayOptions.Add(CreateWeekdayOption(DayOfWeek.Sunday, "SU", Translator.CalendarEventCompose_Weekday_Sunday));
+
+        SelectedReminderOption = GetDefaultReminderOption();
+        SelectedShowAsOption = ShowAsOptions.FirstOrDefault(option => option.ShowAs == CalendarItemShowAs.Busy);
+
+        var (defaultStart, defaultEnd) = GetDefaultComposeDateRange();
+        ApplyDateRange(defaultStart, defaultEnd, false);
+    }
+
+    public override async void OnNavigatedTo(NavigationMode mode, object parameters)
+    {
+        base.OnNavigatedTo(mode, parameters);
+
+        await LoadAvailableCalendarsAsync();
+
+        var args = parameters as CalendarEventComposeNavigationArgs;
+        ApplyNavigationArgs(args);
+        UpdateRecurrenceSummary();
+    }
+
+    partial void OnSelectedCalendarChanged(AccountCalendarViewModel value)
+    {
+        if (value == null)
+            return;
+
+        SelectedShowAsOption = ShowAsOptions.FirstOrDefault(option => option.ShowAs == value.DefaultShowAs)
+                               ?? ShowAsOptions.FirstOrDefault();
+
+        if (IsSelectedCalendarCalDav && Attachments.Count > 0)
+        {
+            Attachments.Clear();
+        }
+
+        OnPropertyChanged(nameof(IsSelectedCalendarCalDav));
+        OnPropertyChanged(nameof(CanAddAttachments));
+        OnPropertyChanged(nameof(AttachmentsDisabledTooltipText));
+        OnPropertyChanged(nameof(SelectedCalendarDisplayText));
+        OnPropertyChanged(nameof(SelectedCalendarAccountText));
+    }
+
+    partial void OnIsAllDayChanged(bool value)
+    {
+        if (value)
+        {
+            if (AllDayEndDate.Date <= StartDate.Date)
+            {
+                AllDayEndDate = StartDate.AddDays(1);
+            }
+        }
+
+        UpdateRecurrenceSummary();
+    }
+
+    partial void OnStartDateChanged(DateTimeOffset value)
+    {
+        if (IsAllDay && AllDayEndDate.Date <= value.Date)
+        {
+            AllDayEndDate = value.AddDays(1);
+        }
+
+        if (IsRecurring && WeekdayOptions.All(option => !option.IsSelected))
+        {
+            SelectSingleWeekday(value.DayOfWeek);
+        }
+
+        UpdateRecurrenceSummary();
+    }
+
+    partial void OnStartTimeChanged(TimeSpan value) => UpdateRecurrenceSummary();
+    partial void OnEndTimeChanged(TimeSpan value) => UpdateRecurrenceSummary();
+    partial void OnAllDayEndDateChanged(DateTimeOffset value) => UpdateRecurrenceSummary();
+    partial void OnIsRecurringChanged(bool value)
+    {
+        if (value && WeekdayOptions.All(option => !option.IsSelected))
+        {
+            SelectSingleWeekday(StartDate.DayOfWeek);
+        }
+
+        UpdateRecurrenceSummary();
+    }
+    partial void OnSelectedRecurrenceIntervalChanged(int value) => UpdateRecurrenceSummary();
+    partial void OnSelectedRecurrenceFrequencyOptionChanged(CalendarComposeFrequencyOption value)
+    {
+        OnPropertyChanged(nameof(IsDailyRecurrenceSelected));
+        UpdateRecurrenceSummary();
+    }
+    partial void OnRecurrenceEndDateChanged(DateTimeOffset? value) => UpdateRecurrenceSummary();
+
+    [RelayCommand]
+    private async Task AddAttachmentsAsync()
+    {
+        if (!CanAddAttachments)
+            return;
+
+        var pickedFiles = await _dialogService.PickFilesMetadataAsync("*");
+        if (pickedFiles.Count == 0)
+            return;
+
+        await ExecuteUIThread(() =>
+        {
+            foreach (var file in pickedFiles)
+            {
+                TryAddAttachment(file.FileName, file.FullFilePath, file.FileExtension, file.Size);
+            }
+        });
+    }
+
+    public bool TryAddAttachment(string filePath, long size)
+    {
+        if (string.IsNullOrWhiteSpace(filePath))
+            return false;
+
+        var fileName = Path.GetFileName(filePath);
+        var fileExtension = Path.GetExtension(filePath);
+        return TryAddAttachment(fileName, filePath, fileExtension, size);
+    }
+
+    [RelayCommand]
+    private void RemoveAttachment(CalendarComposeAttachmentViewModel attachment)
+    {
+        if (attachment == null)
+            return;
+
+        Attachments.Remove(attachment);
+    }
+
+    [RelayCommand]
+    private void ClearRecurrenceEndDate()
+    {
+        RecurrenceEndDate = null;
+    }
+
+    [RelayCommand]
+    private void Cancel()
+    {
+        _navigationService.GoBack();
+    }
+
+    [RelayCommand]
+    private async Task CreateAsync()
+    {
+        var uniqueAttendees = Attendees
+            .GroupBy(attendee => attendee.Email, StringComparer.OrdinalIgnoreCase)
+            .Select(group => group.First())
+            .ToList();
+
+        var createdResult = await BuildResultAsync(uniqueAttendees);
+
+        try
+        {
+            _composeResultValidator.Validate(createdResult);
+        }
+        catch (CalendarEventComposeValidationException ex)
+        {
+            ShowValidationMessage(ex.Message);
+            return;
+        }
+
+        LastCreatedResult = createdResult;
+
+        await _winoRequestDelegator.ExecuteAsync(new CalendarOperationPreparationRequest(
+            CalendarSynchronizerOperation.CreateEvent,
+            ComposeResult: createdResult));
+
+        NavigateBackToCalendar(createdResult.StartDate);
+    }
+
+    private void NavigateBackToCalendar(DateTime targetDate)
+    {
+        _navigationService.Navigate(
+            WinoPage.CalendarPage,
+            new CalendarPageNavigationArgs
+            {
+                NavigationDate = targetDate,
+                ForceReload = true
+            });
+    }
+
+    public async Task<List<AccountContact>> SearchContactsAsync(string queryText)
+    {
+        if (string.IsNullOrWhiteSpace(queryText) || queryText.Length < 2)
+            return [];
+
+        return await _contactService.GetAddressInformationAsync(queryText).ConfigureAwait(false);
+    }
+
+    public async Task<CalendarComposeAttendeeViewModel> GetAttendeeAsync(string tokenText)
+    {
+        if (!EmailValidator.Validate(tokenText))
+            return null;
+
+        var existing = Attendees.Any(attendee => attendee.Email.Equals(tokenText, StringComparison.OrdinalIgnoreCase));
+        if (existing)
+            return null;
+
+        var info = await _contactService.GetAddressInformationByAddressAsync(tokenText).ConfigureAwait(false);
+        if (info != null)
+        {
+            return CalendarComposeAttendeeViewModel.FromContact(info);
+        }
+
+        return new CalendarComposeAttendeeViewModel(string.Empty, tokenText);
+    }
+
+    public void AddAttendee(CalendarComposeAttendeeViewModel attendee)
+    {
+        if (Attendees.Any(existing => existing.Email.Equals(attendee.Email, StringComparison.OrdinalIgnoreCase)))
+            return;
+
+        Attendees.Add(attendee);
+    }
+
+    [RelayCommand]
+    private void RemoveAttendee(CalendarComposeAttendeeViewModel attendee)
+    {
+        if (attendee == null)
+            return;
+
+        Attendees.Remove(attendee);
+    }
+
+    public void NotifyAddressExists()
+    {
+        _dialogService.InfoBarMessage(
+            Translator.Info_ContactExistsTitle,
+            Translator.Info_ContactExistsMessage,
+            InfoBarMessageType.Warning);
+    }
+
+    public void NotifyInvalidEmail(string address)
+    {
+        _dialogService.InfoBarMessage(
+            Translator.Info_InvalidAddressTitle,
+            string.Format(Translator.Info_InvalidAddressMessage, address),
+            InfoBarMessageType.Warning);
+    }
+
+    private async Task LoadAvailableCalendarsAsync()
+    {
+        var accountCalendars = new List<AccountCalendarViewModel>();
+        var groupedCalendars = new List<GroupedAccountCalendarViewModel>();
+        var accounts = await _accountService.GetAccountsAsync().ConfigureAwait(false);
+
+        foreach (var account in accounts)
+        {
+            if (!GroupedAccountCalendarViewModel.SupportsCalendar(account))
+                continue;
+
+            var calendars = await _calendarService.GetAccountCalendarsAsync(account.Id).ConfigureAwait(false);
+            var viewModels = calendars
+                .Select(calendar => new AccountCalendarViewModel(account, calendar))
+                .ToList();
+
+            accountCalendars.AddRange(viewModels);
+
+            if (viewModels.Count > 0)
+            {
+                groupedCalendars.Add(new GroupedAccountCalendarViewModel(account, viewModels));
+            }
+        }
+
+        await ExecuteUIThread(() =>
+        {
+            AvailableCalendars.Clear();
+            AvailableCalendarGroups.Clear();
+
+            foreach (var calendar in accountCalendars.OrderBy(calendar => calendar.Account.Name).ThenBy(calendar => calendar.Name))
+            {
+                AvailableCalendars.Add(calendar);
+            }
+
+            foreach (var group in groupedCalendars.OrderBy(group => group.Account.Name))
+            {
+                AvailableCalendarGroups.Add(group);
+            }
+        });
+    }
+
+    private void ApplyNavigationArgs(CalendarEventComposeNavigationArgs args)
+    {
+        var (defaultStart, defaultEnd) = GetDefaultComposeDateRange();
+        var startDate = args?.StartDate != default ? args!.StartDate : defaultStart;
+        var endDate = args?.EndDate != default ? args!.EndDate : defaultEnd;
+        var isAllDay = args?.IsAllDay ?? false;
+
+        Title = args?.Title ?? string.Empty;
+        Location = args?.Location ?? string.Empty;
+
+        ApplyDateRange(startDate, endDate, isAllDay);
+
+        SelectedCalendar = ResolveSelectedCalendar(args?.SelectedCalendarId);
+        if (SelectedCalendar != null)
+        {
+            SelectedShowAsOption = ShowAsOptions.FirstOrDefault(option => option.ShowAs == SelectedCalendar.DefaultShowAs)
+                                   ?? SelectedShowAsOption
+                                   ?? ShowAsOptions.FirstOrDefault();
+        }
+    }
+
+    private AccountCalendarViewModel ResolveSelectedCalendar(Guid? selectedCalendarId)
+    {
+        if (selectedCalendarId.HasValue)
+        {
+            var selectedCalendar = AvailableCalendars.FirstOrDefault(calendar => calendar.Id == selectedCalendarId.Value);
+            if (selectedCalendar != null)
+                return selectedCalendar;
+        }
+
+        return AvailableCalendars.FirstOrDefault(calendar => calendar.IsPrimary) ?? AvailableCalendars.FirstOrDefault();
+    }
+
+    private void ApplyDateRange(DateTime startDate, DateTime endDate, bool isAllDay)
+    {
+        IsAllDay = isAllDay;
+        StartDate = new DateTimeOffset(startDate.Date);
+        StartTime = startDate.TimeOfDay;
+        EndTime = endDate.TimeOfDay;
+        AllDayEndDate = new DateTimeOffset((isAllDay ? endDate.Date : startDate.Date.AddDays(1)));
+    }
+
+    private async Task<CalendarEventComposeResult> BuildResultAsync(List<CalendarComposeAttendeeViewModel> uniqueAttendees)
+    {
+        if (RecurrenceEndDate.HasValue && RecurrenceEndDate.Value.Date < StartDate.Date)
+        {
+            throw new CalendarEventComposeValidationException(Translator.CalendarEventCompose_ValidationInvalidRecurrenceEnd);
+        }
+
+        var htmlNotes = GetHtmlNotesAsync == null ? string.Empty : await GetHtmlNotesAsync();
+        var effectiveStart = GetEffectiveStartDateTime();
+        var effectiveEnd = GetEffectiveEndDateTime();
+
+        return new CalendarEventComposeResult
+        {
+            CalendarId = SelectedCalendar?.Id ?? Guid.Empty,
+            AccountId = SelectedCalendar?.Account.Id ?? Guid.Empty,
+            Title = Title.Trim(),
+            Location = Location?.Trim() ?? string.Empty,
+            HtmlNotes = htmlNotes,
+            StartDate = effectiveStart,
+            EndDate = effectiveEnd,
+            IsAllDay = IsAllDay,
+            TimeZoneId = TimeZoneInfo.Local.Id,
+            ShowAs = SelectedShowAsOption?.ShowAs ?? SelectedCalendar?.DefaultShowAs ?? CalendarItemShowAs.Busy,
+            SelectedReminders = BuildSelectedReminders(),
+            Attendees = BuildAttendees(uniqueAttendees),
+            Attachments = CanAddAttachments
+                ? Attachments.Select(attachment => attachment.ToDraftModel()).ToList()
+                : [],
+            Recurrence = BuildRecurrenceRule(),
+            RecurrenceSummary = RecurrenceSummary
+        };
+    }
+
+    private List<Reminder> BuildSelectedReminders()
+    {
+        if (SelectedReminderOption == null)
+            return [];
+
+        return
+        [
+            new Reminder
+            {
+                Id = Guid.NewGuid(),
+                CalendarItemId = Guid.Empty,
+                DurationInSeconds = SelectedReminderOption.Minutes * 60L,
+                ReminderType = CalendarItemReminderType.Popup
+            }
+        ];
+    }
+
+    private static List<CalendarEventAttendee> BuildAttendees(IEnumerable<CalendarComposeAttendeeViewModel> attendees)
+    {
+        return attendees
+            .Select(attendee => new CalendarEventAttendee
+            {
+                Id = Guid.NewGuid(),
+                CalendarItemId = Guid.Empty,
+                Name = attendee.HasDistinctDisplayName ? attendee.DisplayName : string.Empty,
+                Email = attendee.Email,
+                AttendenceStatus = AttendeeStatus.NeedsAction,
+                IsOrganizer = false,
+                ResolvedContact = attendee.ResolvedContact
+            })
+            .ToList();
+    }
+
+    private ReminderOption GetDefaultReminderOption()
+    {
+        var reminderMinutes = Math.Max(1, _preferencesService.DefaultReminderDurationInSeconds / 60);
+        return ReminderOptions.FirstOrDefault(option => option.Minutes == reminderMinutes)
+               ?? ReminderOptions.FirstOrDefault();
+    }
+
+    private void UpdateRecurrenceSummary()
+    {
+        if (!HasInitializedComposeDateRange())
+        {
+            RecurrenceSummary = string.Empty;
+            return;
+        }
+
+        var effectiveStart = GetEffectiveStartDateTime();
+        var effectiveEnd = GetEffectiveEndDateTime();
+        var selectedDays = IsDailyRecurrenceSelected
+            ? WeekdayOptions
+                .Where(option => option.IsSelected)
+                .Select(option => option.DayOfWeek)
+                .ToList()
+            : [];
+
+        RecurrenceSummary = CalendarRecurrenceSummaryFormatter.BuildSummary(
+            IsRecurring,
+            effectiveStart,
+            effectiveEnd,
+            IsAllDay,
+            CurrentSettings,
+            SelectedRecurrenceInterval,
+            SelectedRecurrenceFrequencyOption?.Frequency ?? CalendarItemRecurrenceFrequency.Weekly,
+            selectedDays,
+            RecurrenceEndDate);
+    }
+
+    private bool HasInitializedComposeDateRange()
+    {
+        if (StartDate == default)
+        {
+            return false;
+        }
+
+        return !IsAllDay || AllDayEndDate != default;
+    }
+
+    private string BuildRecurrenceRule()
+    {
+        if (!IsRecurring || SelectedRecurrenceFrequencyOption == null)
+            return string.Empty;
+
+        var parts = new List<string>
+        {
+            $"FREQ={SelectedRecurrenceFrequencyOption.Frequency.ToString().ToUpperInvariant()}",
+            $"INTERVAL={SelectedRecurrenceInterval}"
+        };
+
+        var selectedDays = IsDailyRecurrenceSelected
+            ? WeekdayOptions
+                .Where(option => option.IsSelected)
+                .Select(option => option.RuleValue)
+                .ToList()
+            : [];
+
+        if (selectedDays.Count > 0)
+        {
+            parts.Add($"BYDAY={string.Join(",", selectedDays)}");
+        }
+
+        if (RecurrenceEndDate.HasValue)
+        {
+            var untilValue = IsAllDay
+                ? RecurrenceEndDate.Value.ToString("yyyyMMdd", CultureInfo.InvariantCulture)
+                : RecurrenceEndDate.Value.Date.AddDays(1).AddSeconds(-1).ToString("yyyyMMdd'T'HHmmss", CultureInfo.InvariantCulture);
+
+            parts.Add($"UNTIL={untilValue}");
+        }
+
+        return $"RRULE:{string.Join(";", parts)}";
+    }
+
+    private DateTime GetEffectiveStartDateTime()
+        => StartDate.Date.Add(IsAllDay ? TimeSpan.Zero : StartTime);
+
+    private DateTime GetEffectiveEndDateTime()
+        => IsAllDay
+            ? AllDayEndDate.Date
+            : StartDate.Date.Add(EndTime);
+
+    private static (DateTime StartDate, DateTime EndDate) GetDefaultComposeDateRange()
+    {
+        var localNow = DateTime.Now;
+        var roundedMinutes = localNow.Minute switch
+        {
+            < 30 => 30,
+            30 when localNow.Second == 0 && localNow.Millisecond == 0 => 30,
+            _ => 60
+        };
+
+        var startDate = new DateTime(localNow.Year, localNow.Month, localNow.Day, localNow.Hour, 0, 0);
+        startDate = roundedMinutes == 60 ? startDate.AddHours(1) : startDate.AddMinutes(roundedMinutes);
+
+        return (startDate, startDate.AddMinutes(30));
+    }
+
+    private CalendarComposeWeekdayOption CreateWeekdayOption(DayOfWeek dayOfWeek, string ruleValue, string label)
+    {
+        var option = new CalendarComposeWeekdayOption(dayOfWeek, ruleValue, label);
+        option.PropertyChanged += WeekdayOptionPropertyChanged;
+        return option;
+    }
+
+    private void WeekdayOptionPropertyChanged(object sender, PropertyChangedEventArgs e)
+    {
+        if (e.PropertyName == nameof(CalendarComposeWeekdayOption.IsSelected))
+        {
+            UpdateRecurrenceSummary();
+        }
+    }
+
+    private void SelectSingleWeekday(DayOfWeek dayOfWeek)
+    {
+        foreach (var option in WeekdayOptions)
+        {
+            option.IsSelected = option.DayOfWeek == dayOfWeek;
+        }
+    }
+
+    private void ShowValidationMessage(string message)
+    {
+        _dialogService.InfoBarMessage(
+            Translator.CalendarEventCompose_ValidationTitle,
+            message,
+            InfoBarMessageType.Warning);
+    }
+
+    private void AttachmentsCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
+    {
+        OnPropertyChanged(nameof(HasAttachments));
+    }
+
+    private bool TryAddAttachment(string fileName, string filePath, string fileExtension, long size)
+    {
+        if (!CanAddAttachments ||
+            string.IsNullOrWhiteSpace(filePath) ||
+            Attachments.Any(existing => existing.FilePath.Equals(filePath, StringComparison.OrdinalIgnoreCase)))
+        {
+            return false;
+        }
+
+        Attachments.Add(new CalendarComposeAttachmentViewModel(fileName, filePath, fileExtension, size));
+        return true;
+    }
+
+}
+
+public partial class CalendarComposeFrequencyOption : ObservableObject
+{
+    public CalendarItemRecurrenceFrequency Frequency { get; }
+    public string DisplayText { get; }
+
+    public CalendarComposeFrequencyOption(CalendarItemRecurrenceFrequency frequency, string displayText)
+    {
+        Frequency = frequency;
+        DisplayText = displayText;
+    }
+
+    public string PluralLabel(int interval)
+    {
+        if (interval == 1)
+            return DisplayText;
+
+        return Frequency switch
+        {
+            CalendarItemRecurrenceFrequency.Daily => Translator.CalendarEventCompose_FrequencyDayPlural,
+            CalendarItemRecurrenceFrequency.Weekly => Translator.CalendarEventCompose_FrequencyWeekPlural,
+            CalendarItemRecurrenceFrequency.Monthly => Translator.CalendarEventCompose_FrequencyMonthPlural,
+            CalendarItemRecurrenceFrequency.Yearly => Translator.CalendarEventCompose_FrequencyYearPlural,
+            _ => DisplayText
+        };
+    }
+}
+
+public partial class CalendarComposeWeekdayOption : ObservableObject
+{
+    public DayOfWeek DayOfWeek { get; }
+    public string RuleValue { get; }
+    public string Label { get; }
+    public string FullDayName => DayOfWeek switch
+    {
+        DayOfWeek.Monday => CultureInfo.CurrentCulture.DateTimeFormat.DayNames[1],
+        DayOfWeek.Tuesday => CultureInfo.CurrentCulture.DateTimeFormat.DayNames[2],
+        DayOfWeek.Wednesday => CultureInfo.CurrentCulture.DateTimeFormat.DayNames[3],
+        DayOfWeek.Thursday => CultureInfo.CurrentCulture.DateTimeFormat.DayNames[4],
+        DayOfWeek.Friday => CultureInfo.CurrentCulture.DateTimeFormat.DayNames[5],
+        DayOfWeek.Saturday => CultureInfo.CurrentCulture.DateTimeFormat.DayNames[6],
+        DayOfWeek.Sunday => CultureInfo.CurrentCulture.DateTimeFormat.DayNames[0],
+        _ => string.Empty
+    };
+
+    [ObservableProperty]
+    public partial bool IsSelected { get; set; }
+
+    public CalendarComposeWeekdayOption(DayOfWeek dayOfWeek, string ruleValue, string label)
+    {
+        DayOfWeek = dayOfWeek;
+        RuleValue = ruleValue;
+        Label = label;
+    }
+}
+
+

Wino.Calendar.ViewModels/CalendarNotificationSettingsPageViewModel.cs

@@ -0,0 +1,44 @@
+using CommunityToolkit.Mvvm.ComponentModel;
+using Wino.Core.Domain.Interfaces;
+
+namespace Wino.Calendar.ViewModels;
+
+public partial class CalendarNotificationSettingsPageViewModel : CalendarSettingsSectionViewModelBase
+{
+    [ObservableProperty]
+    public partial int SelectedDefaultReminderIndex { get; set; }
+
+    [ObservableProperty]
+    public partial int SelectedDefaultSnoozeIndex { get; set; }
+
+    public CalendarNotificationSettingsPageViewModel(
+        IPreferencesService preferencesService,
+        ICalendarService calendarService,
+        IAccountService accountService)
+        : base(preferencesService, calendarService, accountService)
+    {
+        LoadReminderOptions();
+        LoadSnoozeOptions();
+
+        SelectedDefaultReminderIndex = GetSelectedReminderIndex();
+        SelectedDefaultSnoozeIndex = GetSelectedSnoozeIndex();
+
+        IsLoaded = true;
+    }
+
+    partial void OnSelectedDefaultReminderIndexChanged(int value)
+    {
+        if (!IsLoaded)
+            return;
+
+        SaveReminderIndex(value);
+    }
+
+    partial void OnSelectedDefaultSnoozeIndexChanged(int value)
+    {
+        if (!IsLoaded)
+            return;
+
+        SaveSnoozeIndex(value);
+    }
+}

Wino.Calendar.ViewModels/CalendarPreferenceSettingsPageViewModel.cs

@@ -0,0 +1,62 @@
+using System.Linq;
+using CommunityToolkit.Mvvm.ComponentModel;
+using Wino.Calendar.ViewModels.Data;
+using Wino.Core.Domain.Enums;
+using Wino.Core.Domain.Interfaces;
+
+namespace Wino.Calendar.ViewModels;
+
+public partial class CalendarPreferenceSettingsPageViewModel : CalendarSettingsSectionViewModelBase
+{
+    [ObservableProperty]
+    public partial CalendarNewEventBehaviorOption SelectedNewEventBehaviorOption { get; set; }
+
+    [ObservableProperty]
+    public partial AccountCalendarViewModel SelectedNewEventCalendar { get; set; }
+
+    public bool ShouldShowSpecificNewEventCalendar
+        => SelectedNewEventBehaviorOption?.Behavior == NewEventButtonBehavior.AlwaysUseSpecificCalendar;
+
+    public CalendarPreferenceSettingsPageViewModel(
+        IPreferencesService preferencesService,
+        ICalendarService calendarService,
+        IAccountService accountService)
+        : base(preferencesService, calendarService, accountService)
+    {
+        LoadNewEventBehaviorOptions();
+        SelectedNewEventBehaviorOption = GetSelectedNewEventBehaviorOption();
+
+        IsLoaded = true;
+        LoadCalendarsAsync(ApplyStoredNewEventCalendarPreference);
+    }
+
+    partial void OnSelectedNewEventBehaviorOptionChanged(CalendarNewEventBehaviorOption value)
+    {
+        if (!IsLoaded)
+            return;
+
+        OnPropertyChanged(nameof(ShouldShowSpecificNewEventCalendar));
+        SaveNewEventBehavior(SelectedNewEventBehaviorOption, SelectedNewEventCalendar);
+    }
+
+    partial void OnSelectedNewEventCalendarChanged(AccountCalendarViewModel value)
+    {
+        if (!IsLoaded)
+            return;
+
+        SaveNewEventBehavior(SelectedNewEventBehaviorOption, value);
+    }
+
+    private void ApplyStoredNewEventCalendarPreference()
+    {
+        var configuredCalendar = ResolveSelectedNewEventCalendar();
+        if (PreferencesService.NewEventButtonBehavior == NewEventButtonBehavior.AlwaysUseSpecificCalendar && configuredCalendar == null)
+        {
+            SelectedNewEventBehaviorOption = NewEventBehaviorOptions.First(option => option.Behavior == NewEventButtonBehavior.AskEachTime);
+            SelectedNewEventCalendar = null;
+            return;
+        }
+
+        SelectedNewEventCalendar = configuredCalendar ?? ResolveFallbackNewEventCalendar();
+    }
+}

Wino.Calendar.ViewModels/CalendarRenderingSettingsPageViewModel.cs

@@ -0,0 +1,191 @@
+using System;
+using System.Linq;
+using CommunityToolkit.Mvvm.ComponentModel;
+using Wino.Core.Domain.Interfaces;
+
+namespace Wino.Calendar.ViewModels;
+
+public partial class CalendarRenderingSettingsPageViewModel : CalendarSettingsSectionViewModelBase
+{
+    [ObservableProperty]
+    public partial double CellHourHeight { get; set; }
+
+    [ObservableProperty]
+    public partial int SelectedFirstDayOfWeekIndex { get; set; }
+
+    [ObservableProperty]
+    public partial bool Is24HourHeaders { get; set; }
+
+    [ObservableProperty]
+    public partial bool IsWorkingHoursEnabled { get; set; }
+
+    [ObservableProperty]
+    public partial TimeSpan WorkingHourStart { get; set; }
+
+    [ObservableProperty]
+    public partial TimeSpan WorkingHourEnd { get; set; }
+
+    [ObservableProperty]
+    public partial int WorkingDayStartIndex { get; set; }
+
+    [ObservableProperty]
+    public partial int WorkingDayEndIndex { get; set; }
+
+    [ObservableProperty]
+    public partial string TimedDayHeaderDateFormat { get; set; } = "ddd dd";
+
+    [ObservableProperty]
+    public partial int SelectedTimedDayHeaderFormatPresetIndex { get; set; } = -1;
+
+    public CalendarRenderingSettingsPageViewModel(
+        IPreferencesService preferencesService,
+        ICalendarService calendarService,
+        IAccountService accountService)
+        : base(preferencesService, calendarService, accountService)
+    {
+        SelectedFirstDayOfWeekIndex = DayNames.IndexOf(CalendarCulture.DateTimeFormat.GetDayName(preferencesService.FirstDayOfWeek));
+        Is24HourHeaders = preferencesService.Prefer24HourTimeFormat;
+        IsWorkingHoursEnabled = preferencesService.IsWorkingHoursEnabled;
+        WorkingHourStart = preferencesService.WorkingHourStart;
+        WorkingHourEnd = preferencesService.WorkingHourEnd;
+        CellHourHeight = preferencesService.HourHeight;
+        WorkingDayStartIndex = DayNames.IndexOf(CalendarCulture.DateTimeFormat.GetDayName(preferencesService.WorkingDayStart));
+        WorkingDayEndIndex = DayNames.IndexOf(CalendarCulture.DateTimeFormat.GetDayName(preferencesService.WorkingDayEnd));
+        TimedDayHeaderDateFormat = preferencesService.CalendarTimedDayHeaderDateFormat;
+        SelectedTimedDayHeaderFormatPresetIndex = TimedDayHeaderFormatPresets.IndexOf(TimedDayHeaderDateFormat);
+
+        IsLoaded = true;
+    }
+
+    partial void OnCellHourHeightChanged(double oldValue, double newValue) => SaveSettings();
+
+    partial void OnIs24HourHeadersChanged(bool value)
+    {
+        OnPropertyChanged(nameof(TimedHourLabelPreview));
+        SaveSettings();
+    }
+
+    partial void OnSelectedFirstDayOfWeekIndexChanged(int value) => SaveSettings();
+    partial void OnIsWorkingHoursEnabledChanged(bool value) => SaveSettings();
+    partial void OnWorkingHourStartChanged(TimeSpan value) => SaveSettings();
+    partial void OnWorkingHourEndChanged(TimeSpan value) => SaveSettings();
+    partial void OnWorkingDayStartIndexChanged(int value) => SaveSettings();
+    partial void OnWorkingDayEndIndexChanged(int value) => SaveSettings();
+
+    partial void OnTimedDayHeaderDateFormatChanged(string value)
+    {
+        OnPropertyChanged(nameof(TimedDayHeaderFormatPreview));
+        OnPropertyChanged(nameof(TimedHourLabelPreview));
+
+        var normalizedFormat = string.IsNullOrWhiteSpace(value) ? "ddd dd" : value.Trim();
+        var matchingPresetIndex = TimedDayHeaderFormatPresets
+            .Select((format, index) => new { format, index })
+            .Where(item => string.Equals(item.format, normalizedFormat, StringComparison.Ordinal))
+            .Select(item => item.index)
+            .DefaultIfEmpty(-1)
+            .First();
+
+        if (SelectedTimedDayHeaderFormatPresetIndex != matchingPresetIndex)
+        {
+            SelectedTimedDayHeaderFormatPresetIndex = matchingPresetIndex;
+        }
+
+        SaveSettings();
+    }
+
+    partial void OnSelectedTimedDayHeaderFormatPresetIndexChanged(int value)
+    {
+        if (value < 0 || value >= TimedDayHeaderFormatPresets.Count)
+            return;
+
+        var selectedPreset = TimedDayHeaderFormatPresets[value];
+        if (string.Equals(TimedDayHeaderDateFormat, selectedPreset, StringComparison.Ordinal))
+            return;
+
+        TimedDayHeaderDateFormat = selectedPreset;
+    }
+
+    public string TimedDayHeaderFormatPreview
+    {
+        get
+        {
+            var format = string.IsNullOrWhiteSpace(TimedDayHeaderDateFormat) ? "ddd dd" : TimedDayHeaderDateFormat.Trim();
+            var previewDates = new[]
+            {
+                new DateTime(2026, 3, 23),
+                new DateTime(2026, 3, 24),
+                new DateTime(2026, 3, 25)
+            };
+
+            try
+            {
+                return string.Join(" · ", previewDates.Select(date => date.ToString(format, CalendarCulture)));
+            }
+            catch (FormatException)
+            {
+                return string.Join(" · ", previewDates.Select(date => date.ToString("ddd dd", CalendarCulture)));
+            }
+        }
+    }
+
+    public string TimedHourLabelPreview
+        => string.Join("  ·  ", new[] { 0, 9, 14, 24 }.Select(CurrentSettingsPreviewLabel));
+
+    private string CurrentSettingsPreviewLabel(int hour)
+    {
+        if (Is24HourHeaders)
+            return hour.ToString(CalendarCulture);
+
+        var displayHour = hour % 24;
+        return DateTime.Today.AddHours(displayHour).ToString("h tt", CalendarCulture);
+    }
+
+    private void SaveSettings()
+    {
+        if (!IsLoaded)
+            return;
+
+        PreferencesService.FirstDayOfWeek = SelectedFirstDayOfWeekIndex switch
+        {
+            0 => DayOfWeek.Sunday,
+            1 => DayOfWeek.Monday,
+            2 => DayOfWeek.Tuesday,
+            3 => DayOfWeek.Wednesday,
+            4 => DayOfWeek.Thursday,
+            5 => DayOfWeek.Friday,
+            6 => DayOfWeek.Saturday,
+            _ => throw new ArgumentOutOfRangeException()
+        };
+
+        PreferencesService.WorkingDayStart = WorkingDayStartIndex switch
+        {
+            0 => DayOfWeek.Sunday,
+            1 => DayOfWeek.Monday,
+            2 => DayOfWeek.Tuesday,
+            3 => DayOfWeek.Wednesday,
+            4 => DayOfWeek.Thursday,
+            5 => DayOfWeek.Friday,
+            6 => DayOfWeek.Saturday,
+            _ => throw new ArgumentOutOfRangeException()
+        };
+
+        PreferencesService.WorkingDayEnd = WorkingDayEndIndex switch
+        {
+            0 => DayOfWeek.Sunday,
+            1 => DayOfWeek.Monday,
+            2 => DayOfWeek.Tuesday,
+            3 => DayOfWeek.Wednesday,
+            4 => DayOfWeek.Thursday,
+            5 => DayOfWeek.Friday,
+            6 => DayOfWeek.Saturday,
+            _ => throw new ArgumentOutOfRangeException()
+        };
+
+        PreferencesService.Prefer24HourTimeFormat = Is24HourHeaders;
+        PreferencesService.IsWorkingHoursEnabled = IsWorkingHoursEnabled;
+        PreferencesService.WorkingHourStart = WorkingHourStart;
+        PreferencesService.WorkingHourEnd = WorkingHourEnd;
+        PreferencesService.HourHeight = CellHourHeight;
+        PreferencesService.CalendarTimedDayHeaderDateFormat = TimedDayHeaderDateFormat;
+    }
+}

Wino.Calendar.ViewModels/CalendarSettingsSectionViewModelBase.cs

@@ -0,0 +1,197 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Globalization;
+using System.Linq;
+using Wino.Calendar.ViewModels.Data;
+using Wino.Core.Domain;
+using Wino.Core.Domain.Enums;
+using Wino.Core.Domain.Interfaces;
+using Wino.Core.Domain.Translations;
+using Wino.Core.ViewModels;
+
+namespace Wino.Calendar.ViewModels;
+
+public abstract class CalendarSettingsSectionViewModelBase : CalendarBaseViewModel
+{
+    protected CalendarSettingsSectionViewModelBase(
+        IPreferencesService preferencesService,
+        ICalendarService calendarService,
+        IAccountService accountService)
+    {
+        PreferencesService = preferencesService;
+        CalendarService = calendarService;
+        AccountService = accountService;
+
+        var languageCode = WinoTranslationDictionary.GetLanguageFileNameRelativePath(preferencesService.CurrentLanguage);
+        CalendarCulture = new CultureInfo(languageCode);
+
+        for (var index = 0; index < 7; index++)
+        {
+            DayNames.Add(CalendarCulture.DateTimeFormat.DayNames[index]);
+        }
+    }
+
+    protected IPreferencesService PreferencesService { get; }
+    protected ICalendarService CalendarService { get; }
+    protected IAccountService AccountService { get; }
+    protected CultureInfo CalendarCulture { get; }
+    protected bool IsLoaded { get; set; }
+
+    public ObservableCollection<string> DayNames { get; } = [];
+    public ObservableCollection<string> ReminderOptions { get; } = [];
+    public ObservableCollection<string> SnoozeOptions { get; } = [];
+    public ObservableCollection<CalendarNewEventBehaviorOption> NewEventBehaviorOptions { get; } = [];
+    public ObservableCollection<AccountCalendarViewModel> AvailableNewEventCalendars { get; } = [];
+    public ObservableCollection<string> TimedDayHeaderFormatPresets { get; } =
+    [
+        "ddd dd",
+        "dddd dd",
+        "ddd d MMM",
+        "dd MMM ddd",
+        "M/d ddd"
+    ];
+
+    protected void LoadReminderOptions()
+    {
+        ReminderOptions.Clear();
+
+        var predefinedMinutes = CalendarService.GetPredefinedReminderMinutes();
+        ReminderOptions.Add("None");
+
+        foreach (var minutes in predefinedMinutes)
+        {
+            var displayText = minutes switch
+            {
+                >= 60 => $"{minutes / 60} Hour{(minutes / 60 > 1 ? "s" : "")}",
+                _ => $"{minutes} Minute{(minutes > 1 ? "s" : "")}"
+            };
+
+            ReminderOptions.Add(displayText);
+        }
+    }
+
+    protected int GetSelectedReminderIndex()
+    {
+        if (PreferencesService.DefaultReminderDurationInSeconds == 0)
+            return 0;
+
+        var minutes = (int)(PreferencesService.DefaultReminderDurationInSeconds / 60);
+        var predefinedMinutes = CalendarService.GetPredefinedReminderMinutes();
+        var index = Array.IndexOf(predefinedMinutes, minutes);
+        return index >= 0 ? index + 1 : 0;
+    }
+
+    protected void SaveReminderIndex(int selectedDefaultReminderIndex)
+    {
+        if (selectedDefaultReminderIndex == 0)
+        {
+            PreferencesService.DefaultReminderDurationInSeconds = 0;
+            return;
+        }
+
+        var predefinedMinutes = CalendarService.GetPredefinedReminderMinutes();
+        var minutes = predefinedMinutes[selectedDefaultReminderIndex - 1];
+        PreferencesService.DefaultReminderDurationInSeconds = minutes * 60;
+    }
+
+    protected void LoadSnoozeOptions()
+    {
+        SnoozeOptions.Clear();
+
+        foreach (var snoozeMinutes in CalendarReminderSnoozeOptions.GetSupportedSnoozeMinutes())
+        {
+            SnoozeOptions.Add(string.Format(Translator.CalendarReminder_SnoozeMinutesOption, snoozeMinutes));
+        }
+    }
+
+    protected int GetSelectedSnoozeIndex()
+    {
+        var supportedSnoozeMinutes = CalendarReminderSnoozeOptions.GetSupportedSnoozeMinutes().ToArray();
+        var selectedIndex = Array.IndexOf(supportedSnoozeMinutes, PreferencesService.DefaultSnoozeDurationInMinutes);
+        return selectedIndex >= 0 ? selectedIndex : 0;
+    }
+
+    protected void SaveSnoozeIndex(int selectedDefaultSnoozeIndex)
+    {
+        var supportedSnoozeMinutes = CalendarReminderSnoozeOptions.GetSupportedSnoozeMinutes();
+        if (supportedSnoozeMinutes.Count == 0)
+            return;
+
+        var selectedIndex = Math.Clamp(selectedDefaultSnoozeIndex, 0, supportedSnoozeMinutes.Count - 1);
+        PreferencesService.DefaultSnoozeDurationInMinutes = supportedSnoozeMinutes[selectedIndex];
+    }
+
+    protected void LoadNewEventBehaviorOptions()
+    {
+        NewEventBehaviorOptions.Clear();
+        NewEventBehaviorOptions.Add(new CalendarNewEventBehaviorOption(NewEventButtonBehavior.AskEachTime, Translator.CalendarSettings_NewEventBehavior_AskEachTime));
+        NewEventBehaviorOptions.Add(new CalendarNewEventBehaviorOption(NewEventButtonBehavior.AlwaysUseSpecificCalendar, Translator.CalendarSettings_NewEventBehavior_AlwaysUseSpecificCalendar));
+    }
+
+    protected CalendarNewEventBehaviorOption GetSelectedNewEventBehaviorOption()
+        => NewEventBehaviorOptions.FirstOrDefault(option => option.Behavior == PreferencesService.NewEventButtonBehavior)
+           ?? NewEventBehaviorOptions.First();
+
+    protected async void LoadCalendarsAsync(Action applySelection)
+    {
+        var accounts = await AccountService.GetAccountsAsync().ConfigureAwait(false);
+        var calendarsByAccount = new List<AccountCalendarViewModel>();
+
+        foreach (var account in accounts)
+        {
+            var calendars = await CalendarService.GetAccountCalendarsAsync(account.Id).ConfigureAwait(false);
+            calendarsByAccount.AddRange(calendars.Select(calendar => new AccountCalendarViewModel(account, calendar)));
+        }
+
+        await ExecuteUIThread(() =>
+        {
+            AvailableNewEventCalendars.Clear();
+
+            foreach (var calendar in calendarsByAccount)
+            {
+                AvailableNewEventCalendars.Add(calendar);
+            }
+
+            applySelection();
+        });
+    }
+
+    protected AccountCalendarViewModel ResolveSelectedNewEventCalendar()
+    {
+        var configuredCalendarId = PreferencesService.DefaultNewEventCalendarId;
+        return configuredCalendarId.HasValue
+            ? AvailableNewEventCalendars.FirstOrDefault(calendar => calendar.Id == configuredCalendarId.Value)
+            : null;
+    }
+
+    protected AccountCalendarViewModel ResolveFallbackNewEventCalendar()
+        => AvailableNewEventCalendars.FirstOrDefault(calendar => calendar.IsPrimary)
+           ?? AvailableNewEventCalendars.FirstOrDefault();
+
+    protected void SaveNewEventBehavior(CalendarNewEventBehaviorOption selectedBehaviorOption, AccountCalendarViewModel selectedCalendar)
+    {
+        var newEventBehavior = selectedBehaviorOption?.Behavior ?? NewEventButtonBehavior.AskEachTime;
+        if (newEventBehavior == NewEventButtonBehavior.AlwaysUseSpecificCalendar && selectedCalendar != null)
+        {
+            PreferencesService.NewEventButtonBehavior = NewEventButtonBehavior.AlwaysUseSpecificCalendar;
+            PreferencesService.DefaultNewEventCalendarId = selectedCalendar.Id;
+            return;
+        }
+
+        PreferencesService.NewEventButtonBehavior = NewEventButtonBehavior.AskEachTime;
+        PreferencesService.DefaultNewEventCalendarId = null;
+    }
+}
+
+public sealed class CalendarNewEventBehaviorOption
+{
+    public CalendarNewEventBehaviorOption(NewEventButtonBehavior behavior, string displayText)
+    {
+        Behavior = behavior;
+        DisplayText = displayText;
+    }
+
+    public NewEventButtonBehavior Behavior { get; }
+    public string DisplayText { get; }
+}

Wino.Calendar.ViewModels/Data/AccountCalendarViewModel.cs

@@ -0,0 +1,93 @@
+using System;
+using CommunityToolkit.Mvvm.ComponentModel;
+using Wino.Core.Domain.Entities.Calendar;
+using Wino.Core.Domain.Entities.Shared;
+using Wino.Core.Domain.Enums;
+using Wino.Core.Domain.Interfaces;
+
+namespace Wino.Calendar.ViewModels.Data;
+
+public partial class AccountCalendarViewModel : ObservableObject, IAccountCalendar
+{
+    public MailAccount Account { get; }
+    public AccountCalendar AccountCalendar { get; }
+
+    public AccountCalendarViewModel(MailAccount account, AccountCalendar accountCalendar)
+    {
+        Account = account;
+        AccountCalendar = accountCalendar;
+
+        IsChecked = accountCalendar.IsExtended;
+    }
+
+    [ObservableProperty]
+    private bool _isChecked;
+
+    partial void OnIsCheckedChanged(bool value) => IsExtended = value;
+
+    public string Name
+    {
+        get => AccountCalendar.Name;
+        set => SetProperty(AccountCalendar.Name, value, AccountCalendar, (u, n) => u.Name = n);
+    }
+
+    public string TextColorHex
+    {
+        get => AccountCalendar.TextColorHex;
+        set => SetProperty(AccountCalendar.TextColorHex, value, AccountCalendar, (u, t) => u.TextColorHex = t);
+    }
+
+    public string BackgroundColorHex
+    {
+        get => AccountCalendar.BackgroundColorHex;
+        set => SetProperty(AccountCalendar.BackgroundColorHex, value, AccountCalendar, (u, b) => u.BackgroundColorHex = b);
+    }
+
+    public bool IsExtended
+    {
+        get => AccountCalendar.IsExtended;
+        set => SetProperty(AccountCalendar.IsExtended, value, AccountCalendar, (u, i) => u.IsExtended = i);
+    }
+
+    public bool IsPrimary
+    {
+        get => AccountCalendar.IsPrimary;
+        set => SetProperty(AccountCalendar.IsPrimary, value, AccountCalendar, (u, i) => u.IsPrimary = i);
+    }
+
+    public bool IsReadOnly
+    {
+        get => AccountCalendar.IsReadOnly;
+        set => SetProperty(AccountCalendar.IsReadOnly, value, AccountCalendar, (u, i) => u.IsReadOnly = i);
+    }
+
+    public bool IsSynchronizationEnabled
+    {
+        get => AccountCalendar.IsSynchronizationEnabled;
+        set => SetProperty(AccountCalendar.IsSynchronizationEnabled, value, AccountCalendar, (u, i) => u.IsSynchronizationEnabled = i);
+    }
+
+    public Guid AccountId
+    {
+        get => AccountCalendar.AccountId;
+        set => SetProperty(AccountCalendar.AccountId, value, AccountCalendar, (u, a) => u.AccountId = a);
+    }
+
+    public string RemoteCalendarId
+    {
+        get => AccountCalendar.RemoteCalendarId;
+        set => SetProperty(AccountCalendar.RemoteCalendarId, value, AccountCalendar, (u, r) => u.RemoteCalendarId = r);
+    }
+
+    public CalendarItemShowAs DefaultShowAs
+    {
+        get => AccountCalendar.DefaultShowAs;
+        set => SetProperty(AccountCalendar.DefaultShowAs, value, AccountCalendar, (u, s) => u.DefaultShowAs = s);
+    }
+    public Guid Id { get => ((IAccountCalendar)AccountCalendar).Id; set => ((IAccountCalendar)AccountCalendar).Id = value; }
+    public MailAccount MailAccount
+    {
+        get => AccountCalendar.MailAccount ?? Account;
+        set => AccountCalendar.MailAccount = value;
+    }
+}

Wino.Calendar.ViewModels/Data/CalendarAttachmentViewModel.cs

@@ -0,0 +1,71 @@
+using System;
+using System.IO;
+using CommunityToolkit.Mvvm.ComponentModel;
+using Wino.Core.Domain.Entities.Calendar;
+using Wino.Core.Domain.Enums;
+using Wino.Core.Extensions;
+
+namespace Wino.Calendar.ViewModels.Data;
+
+public partial class CalendarAttachmentViewModel : ObservableObject
+{
+    public CalendarAttachment Attachment { get; }
+
+    public Guid Id => Attachment.Id;
+    public string FileName => Attachment.FileName;
+    public string ReadableSize { get; }
+    public MailAttachmentType AttachmentType { get; }
+    public bool IsDownloaded => Attachment.IsDownloaded;
+
+    [ObservableProperty]
+    public partial bool IsBusy { get; set; }
+
+    public CalendarAttachmentViewModel(CalendarAttachment attachment)
+    {
+        Attachment = attachment;
+        ReadableSize = attachment.Size.GetBytesReadable();
+
+        var extension = Path.GetExtension(FileName);
+        AttachmentType = GetAttachmentType(extension);
+    }
+
+    private MailAttachmentType GetAttachmentType(string extension)
+    {
+        if (string.IsNullOrEmpty(extension))
+            return MailAttachmentType.None;
+
+        switch (extension.ToLower())
+        {
+            case ".exe":
+                return MailAttachmentType.Executable;
+            case ".rar":
+                return MailAttachmentType.RarArchive;
+            case ".zip":
+                return MailAttachmentType.Archive;
+            case ".ogg":
+            case ".mp3":
+            case ".wav":
+            case ".aac":
+            case ".alac":
+                return MailAttachmentType.Audio;
+            case ".mp4":
+            case ".wmv":
+            case ".avi":
+            case ".flv":
+                return MailAttachmentType.Video;
+            case ".pdf":
+                return MailAttachmentType.PDF;
+            case ".htm":
+            case ".html":
+                return MailAttachmentType.HTML;
+            case ".png":
+            case ".jpg":
+            case ".jpeg":
+            case ".gif":
+            case ".jiff":
+                return MailAttachmentType.Image;
+            default:
+                return MailAttachmentType.Other;
+        }
+    }
+}

Wino.Calendar.ViewModels/Data/CalendarComposeAttachmentViewModel.cs

@@ -0,0 +1,57 @@
+using System;
+using Wino.Core.Domain.Enums;
+using Wino.Core.Domain.Models.Calendar;
+using Wino.Core.Extensions;
+
+namespace Wino.Calendar.ViewModels.Data;
+
+public class CalendarComposeAttachmentViewModel
+{
+    public Guid Id { get; } = Guid.NewGuid();
+    public string FileName { get; }
+    public string FilePath { get; }
+    public string FileExtension { get; }
+    public long Size { get; }
+    public string ReadableSize => Size.GetBytesReadable();
+    public MailAttachmentType AttachmentType { get; }
+
+    public CalendarComposeAttachmentViewModel(string fileName, string filePath, string fileExtension, long size)
+    {
+        FileName = fileName;
+        FilePath = filePath;
+        FileExtension = fileExtension;
+        Size = size;
+        AttachmentType = GetAttachmentType(fileExtension);
+    }
+
+    public CalendarEventComposeAttachmentDraft ToDraftModel()
+    {
+        return new CalendarEventComposeAttachmentDraft
+        {
+            Id = Id,
+            FileName = FileName,
+            FilePath = FilePath,
+            FileExtension = FileExtension,
+            Size = Size
+        };
+    }
+
+    private static MailAttachmentType GetAttachmentType(string extension)
+    {
+        if (string.IsNullOrWhiteSpace(extension))
+            return MailAttachmentType.None;
+
+        return extension.ToLowerInvariant() switch
+        {
+            ".exe" => MailAttachmentType.Executable,
+            ".rar" => MailAttachmentType.RarArchive,
+            ".zip" => MailAttachmentType.Archive,
+            ".ogg" or ".mp3" or ".wav" or ".aac" or ".alac" => MailAttachmentType.Audio,
+            ".mp4" or ".wmv" or ".avi" or ".flv" => MailAttachmentType.Video,
+            ".pdf" => MailAttachmentType.PDF,
+            ".htm" or ".html" => MailAttachmentType.HTML,
+            ".png" or ".jpg" or ".jpeg" or ".gif" or ".jiff" => MailAttachmentType.Image,
+            _ => MailAttachmentType.Other
+        };
+    }
+}

Wino.Calendar.ViewModels/Data/CalendarComposeAttendeeViewModel.cs

@@ -0,0 +1,23 @@
+using Wino.Core.Domain.Entities.Shared;
+
+namespace Wino.Calendar.ViewModels.Data;
+
+public class CalendarComposeAttendeeViewModel : IContactDisplayItem
+{
+    public string DisplayName { get; }
+    public string Email { get; }
+    public AccountContact ResolvedContact { get; }
+    public string Address => Email;
+    public AccountContact PreviewContact => ResolvedContact;
+    public bool HasDistinctDisplayName => !string.IsNullOrWhiteSpace(DisplayName) && !DisplayName.Equals(Email, System.StringComparison.OrdinalIgnoreCase);
+
+    public CalendarComposeAttendeeViewModel(string displayName, string email, AccountContact resolvedContact = null)
+    {
+        DisplayName = string.IsNullOrWhiteSpace(displayName) ? email : displayName;
+        Email = email;
+        ResolvedContact = resolvedContact;
+    }
+
+    public static CalendarComposeAttendeeViewModel FromContact(AccountContact contact)
+        => new(contact.Name, contact.Address, contact);
+}

Wino.Calendar.ViewModels/Data/CalendarItemViewModel.cs

@@ -0,0 +1,198 @@
+using System;
+using System.Collections.ObjectModel;
+using CommunityToolkit.Mvvm.ComponentModel;
+using Itenso.TimePeriod;
+using Wino.Core.Domain;
+using Wino.Core.Domain.Entities.Calendar;
+using Wino.Core.Domain.Extensions;
+using Wino.Core.Domain.Interfaces;
+using Wino.Core.Domain.Models.Calendar;
+
+namespace Wino.Calendar.ViewModels.Data;
+
+public partial class CalendarItemViewModel : ObservableObject, ICalendarItem, ICalendarItemViewModel
+{
+    public CalendarItem CalendarItem { get; }
+
+    public string Title => CalendarItem.Title;
+
+    public Guid Id => CalendarItem.Id;
+
+    public IAccountCalendar AssignedCalendar => CalendarItem.AssignedCalendar;
+
+    /// <summary>
+    /// Gets or sets the start date converted to user's local timezone for display.
+    /// The underlying CalendarItem stores dates according to their timezone.
+    /// </summary>
+    public DateTime StartDate
+    {
+        get
+        {
+            // Get start date in user's local timezone
+            return CalendarItem.LocalStartDate;
+        }
+        set
+        {
+            // All-day events use floating dates and should not shift across timezones.
+            CalendarItem.StartDate = CalendarItem.IsAllDayEvent
+                ? value.Date
+                : value.ToTimeZoneFromLocal(CalendarItem.StartTimeZone);
+        }
+    }
+
+    /// <summary>
+    /// Gets the end date converted to user's local timezone for display.
+    /// The underlying CalendarItem stores dates according to their timezone.
+    /// </summary>
+    public DateTime EndDate
+    {
+        get
+        {
+            // Get end date in user's local timezone
+            return CalendarItem.LocalEndDate;
+        }
+    }
+
+    public double DurationInSeconds { get => CalendarItem.DurationInSeconds; set => CalendarItem.DurationInSeconds = value; }
+
+    /// <summary>
+    /// Gets the time period in local time.
+    /// </summary>
+    public ITimePeriod Period
+    {
+        get
+        {
+            // Return a period using local times for UI display
+            return new TimeRange(StartDate, EndDate);
+        }
+    }
+
+    public bool IsAllDayEvent => CalendarItem.IsAllDayEvent;
+    public bool IsMultiDayEvent => CalendarItem.IsMultiDayEvent;
+    public bool IsRecurringEvent => CalendarItem.IsRecurringEvent;
+    public bool IsRecurringChild => CalendarItem.IsRecurringChild;
+    public bool IsRecurringParent => CalendarItem.IsRecurringParent;
+    public bool CanDragDrop => CalendarItem.CanChangeStartAndEndDate;
+
+    [ObservableProperty]
+    public partial bool IsSelected { get; set; }
+
+    [ObservableProperty]
+    public partial bool IsBusy { get; set; }
+
+    /// <summary>
+    /// The period of the day where this item is currently being displayed.
+    /// Used for multi-day event title formatting.
+    /// </summary>
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(DisplayTitle))]
+    public partial ITimePeriod DisplayingPeriod { get; set; }
+
+    /// <summary>
+    /// Calendar settings for time formatting.
+    /// </summary>
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(DisplayTitle))]
+    public partial CalendarSettings CalendarSettings { get; set; }
+
+    /// <summary>
+    /// Gets the display title based on the current displaying period.
+    /// </summary>
+    public string DisplayTitle
+    {
+        get
+        {
+            if (DisplayingPeriod == null || CalendarSettings == null)
+                return Title;
+
+            return GetDisplayTitle(DisplayingPeriod, CalendarSettings);
+        }
+    }
+
+    public ObservableCollection<CalendarEventAttendee> Attendees { get; } = new ObservableCollection<CalendarEventAttendee>();
+
+    public CalendarItemViewModel(CalendarItem calendarItem)
+    {
+        CalendarItem = calendarItem;
+    }
+
+    /// <summary>
+    /// Updates the underlying CalendarItem with new data and raises property change notifications.
+    /// </summary>
+    /// <param name="calendarItem">The updated calendar item data.</param>
+    public void UpdateFrom(CalendarItem calendarItem)
+    {
+        if (calendarItem == null || calendarItem.Id != CalendarItem.Id)
+            return;
+
+        // Update all mutable properties
+        CalendarItem.Title = calendarItem.Title;
+        CalendarItem.Description = calendarItem.Description;
+        CalendarItem.Location = calendarItem.Location;
+        CalendarItem.StartDate = calendarItem.StartDate;
+        CalendarItem.StartTimeZone = calendarItem.StartTimeZone;
+        CalendarItem.EndTimeZone = calendarItem.EndTimeZone;
+        CalendarItem.DurationInSeconds = calendarItem.DurationInSeconds;
+        CalendarItem.Recurrence = calendarItem.Recurrence;
+        CalendarItem.RecurringCalendarItemId = calendarItem.RecurringCalendarItemId;
+        CalendarItem.OrganizerDisplayName = calendarItem.OrganizerDisplayName;
+        CalendarItem.OrganizerEmail = calendarItem.OrganizerEmail;
+        CalendarItem.IsLocked = calendarItem.IsLocked;
+        CalendarItem.IsHidden = calendarItem.IsHidden;
+        CalendarItem.CustomEventColorHex = calendarItem.CustomEventColorHex;
+        CalendarItem.HtmlLink = calendarItem.HtmlLink;
+        CalendarItem.Status = calendarItem.Status;
+        CalendarItem.Visibility = calendarItem.Visibility;
+        CalendarItem.ShowAs = calendarItem.ShowAs;
+        CalendarItem.UpdatedAt = calendarItem.UpdatedAt;
+        CalendarItem.AssignedCalendar = calendarItem.AssignedCalendar;
+
+        // Raise property changed for all bindable properties
+        OnPropertyChanged(nameof(Title));
+        OnPropertyChanged(nameof(StartDate));
+        OnPropertyChanged(nameof(EndDate));
+        OnPropertyChanged(nameof(DurationInSeconds));
+        OnPropertyChanged(nameof(Period));
+        OnPropertyChanged(nameof(IsAllDayEvent));
+        OnPropertyChanged(nameof(IsMultiDayEvent));
+        OnPropertyChanged(nameof(IsRecurringEvent));
+        OnPropertyChanged(nameof(IsRecurringChild));
+        OnPropertyChanged(nameof(IsRecurringParent));
+        OnPropertyChanged(nameof(CanDragDrop));
+        OnPropertyChanged(nameof(AssignedCalendar));
+        OnPropertyChanged(nameof(DisplayTitle));
+    }
+
+    /// <summary>
+    /// Gets the display title for this calendar item when rendered in a specific day.
+    /// </summary>
+    public string GetDisplayTitle(ITimePeriod displayingPeriod, CalendarSettings calendarSettings)
+    {
+        if (!IsMultiDayEvent)
+            return Title;
+
+        var periodRelation = Period.GetRelation(displayingPeriod);
+
+        if (periodRelation == PeriodRelation.StartInside || periodRelation == PeriodRelation.EnclosingStartTouching)
+        {
+            // Event starts within this day: "HH:mm -> Title"
+            return $"{calendarSettings.GetTimeString(StartDate.TimeOfDay)} -> {Title}";
+        }
+        else if (periodRelation == PeriodRelation.EndInside || periodRelation == PeriodRelation.EnclosingEndTouching)
+        {
+            // Event ends within this day: "Title <- HH:mm"
+            return $"{Title} <- {calendarSettings.GetTimeString(EndDate.TimeOfDay)}";
+        }
+        else if (periodRelation == PeriodRelation.Enclosing)
+        {
+            // Event spans the entire day
+            return $"{Translator.CalendarItemAllDay} {Title}";
+        }
+        else
+        {
+            return Title;
+        }
+    }
+
+    public override string ToString() => CalendarItem.Title;
+}

Wino.Calendar.ViewModels/Data/GroupedAccountCalendarViewModel.cs

@@ -0,0 +1,207 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.Linq;
+using CommunityToolkit.Mvvm.ComponentModel;
+using Wino.Core.Domain.Entities.Shared;
+using Wino.Core.Domain.Models.Synchronization;
+
+namespace Wino.Calendar.ViewModels.Data;
+
+public partial class GroupedAccountCalendarViewModel : ObservableObject
+{
+    public event EventHandler CollectiveSelectionStateChanged;
+    public event EventHandler<AccountCalendarViewModel> CalendarSelectionStateChanged;
+
+    public MailAccount Account { get; }
+    public ObservableCollection<AccountCalendarViewModel> AccountCalendars { get; }
+
+    public static bool SupportsCalendar(MailAccount account)
+        => account?.IsCalendarAccessGranted == true;
+
+    public GroupedAccountCalendarViewModel(MailAccount account, IEnumerable<AccountCalendarViewModel> calendarViewModels)
+    {
+        Account = account;
+        AccountCalendars = new ObservableCollection<AccountCalendarViewModel>(calendarViewModels);
+        AccountColorHex = account.AccountColorHex;
+
+        ManageIsCheckedState();
+
+        foreach (var calendarViewModel in calendarViewModels)
+        {
+            calendarViewModel.PropertyChanged += CalendarPropertyChanged;
+        }
+
+        AccountCalendars.CollectionChanged += CalendarListUpdated;
+    }
+
+    private void CalendarListUpdated(object sender, NotifyCollectionChangedEventArgs e)
+    {
+        if (e.Action == NotifyCollectionChangedAction.Add)
+        {
+            foreach (AccountCalendarViewModel calendar in e.NewItems)
+            {
+                calendar.PropertyChanged += CalendarPropertyChanged;
+            }
+        }
+        else if (e.Action == NotifyCollectionChangedAction.Remove)
+        {
+            foreach (AccountCalendarViewModel calendar in e.OldItems)
+            {
+                calendar.PropertyChanged -= CalendarPropertyChanged;
+            }
+        }
+        else if (e.Action == NotifyCollectionChangedAction.Reset)
+        {
+            foreach (AccountCalendarViewModel calendar in e.OldItems)
+            {
+                calendar.PropertyChanged -= CalendarPropertyChanged;
+            }
+        }
+    }
+
+    private void CalendarPropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
+    {
+        if (sender is AccountCalendarViewModel viewModel &&
+            e.PropertyName == nameof(AccountCalendarViewModel.IsChecked))
+        {
+            ManageIsCheckedState();
+            UpdateCalendarCheckedState(viewModel, viewModel.IsChecked, true);
+        }
+    }
+
+    [ObservableProperty]
+    public partial bool IsExpanded { get; set; } = true;
+
+    [ObservableProperty]
+    public partial bool? IsCheckedState { get; set; } = true;
+
+    [ObservableProperty]
+    public partial string AccountColorHex { get; set; } = string.Empty;
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(CanSynchronize), nameof(IsSynchronizationProgressVisible), nameof(IsProgressIndeterminate))]
+    public partial bool IsSynchronizationInProgress { get; set; }
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(SynchronizationProgress), nameof(SynchronizationProgressValue), nameof(IsProgressIndeterminate))]
+    public partial int TotalItemsToSync { get; set; }
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(SynchronizationProgress), nameof(SynchronizationProgressValue), nameof(IsProgressIndeterminate))]
+    public partial int RemainingItemsToSync { get; set; }
+
+    [ObservableProperty]
+    public partial string SynchronizationStatus { get; set; } = string.Empty;
+
+    public bool CanSynchronize => !IsSynchronizationInProgress;
+    public bool IsSynchronizationProgressVisible => IsSynchronizationInProgress;
+    public bool IsProgressIndeterminate => IsSynchronizationInProgress && TotalItemsToSync <= 0;
+    public string AccountAddressDisplay => string.IsNullOrWhiteSpace(Account?.Address) ? string.Empty : $" ({Account.Address})";
+
+    public double SynchronizationProgress
+    {
+        get
+        {
+            if (TotalItemsToSync <= 0)
+                return 0;
+
+            return ((double)(TotalItemsToSync - RemainingItemsToSync) / TotalItemsToSync) * 100;
+        }
+    }
+
+    public double SynchronizationProgressValue => SynchronizationProgress;
+
+    private bool _isExternalPropChangeBlocked;
+
+    public void ApplySynchronizationProgress(AccountSynchronizationProgress progress)
+    {
+        if (progress == null || progress.AccountId != Account.Id)
+            return;
+
+        IsSynchronizationInProgress = progress.IsInProgress;
+        TotalItemsToSync = progress.TotalUnits;
+        RemainingItemsToSync = progress.RemainingUnits;
+        SynchronizationStatus = progress.Status ?? string.Empty;
+    }
+
+    private void ManageIsCheckedState()
+    {
+        if (_isExternalPropChangeBlocked)
+            return;
+
+        _isExternalPropChangeBlocked = true;
+
+        if (AccountCalendars.All(c => c.IsChecked))
+        {
+            IsCheckedState = true;
+        }
+        else if (AccountCalendars.All(c => !c.IsChecked))
+        {
+            IsCheckedState = false;
+        }
+        else
+        {
+            IsCheckedState = null;
+        }
+
+        _isExternalPropChangeBlocked = false;
+    }
+
+    partial void OnIsCheckedStateChanged(bool? oldValue, bool? newValue)
+    {
+        if (_isExternalPropChangeBlocked)
+            return;
+
+        _isExternalPropChangeBlocked = true;
+
+        if (newValue == null)
+        {
+            foreach (var calendar in AccountCalendars)
+            {
+                UpdateCalendarCheckedState(calendar, calendar.IsPrimary);
+            }
+        }
+        else
+        {
+            foreach (var calendar in AccountCalendars)
+            {
+                UpdateCalendarCheckedState(calendar, newValue.GetValueOrDefault());
+            }
+        }
+
+        _isExternalPropChangeBlocked = false;
+        CollectiveSelectionStateChanged?.Invoke(this, EventArgs.Empty);
+    }
+
+    private void UpdateCalendarCheckedState(AccountCalendarViewModel accountCalendarViewModel, bool newValue, bool ignoreValueCheck = false)
+    {
+        var currentValue = accountCalendarViewModel.IsChecked;
+
+        if (currentValue == newValue && !ignoreValueCheck)
+            return;
+
+        accountCalendarViewModel.IsChecked = newValue;
+
+        if (_isExternalPropChangeBlocked)
+            return;
+
+        CalendarSelectionStateChanged?.Invoke(this, accountCalendarViewModel);
+    }
+
+    public void UpdateAccount(MailAccount updatedAccount)
+    {
+        if (updatedAccount == null || updatedAccount.Id != Account.Id)
+            return;
+
+        Account.Name = updatedAccount.Name;
+        Account.Address = updatedAccount.Address;
+        Account.AccountColorHex = updatedAccount.AccountColorHex;
+        Account.AttentionReason = updatedAccount.AttentionReason;
+        Account.MergedInboxId = updatedAccount.MergedInboxId;
+        AccountColorHex = updatedAccount.AccountColorHex;
+        OnPropertyChanged(nameof(Account));
+        OnPropertyChanged(nameof(AccountAddressDisplay));
+    }
+}

Wino.Calendar.ViewModels/EventDetailsPageViewModel.cs

@@ -0,0 +1,884 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using CommunityToolkit.Mvvm.Messaging;
+using Serilog;
+using Wino.Calendar.ViewModels.Data;
+using Wino.Core.Domain;
+using Wino.Core.Domain.Entities.Calendar;
+using Wino.Core.Domain.Extensions;
+using Wino.Core.Domain.Enums;
+using Wino.Core.Domain.Interfaces;
+using Wino.Core.Domain.Models.Calendar;
+using Wino.Core.Domain.Models;
+using Wino.Core.Domain.Models.Navigation;
+using Wino.Core.Services;
+using Wino.Core.ViewModels;
+using Wino.Messaging.Client.Calendar;
+
+namespace Wino.Calendar.ViewModels;
+
+public partial class EventDetailsPageViewModel : CalendarBaseViewModel
+{
+    private readonly ICalendarService _calendarService;
+    private readonly INativeAppService _nativeAppService;
+    private readonly IPreferencesService _preferencesService;
+    private readonly IMailDialogService _dialogService;
+    private readonly IWinoRequestDelegator _winoRequestDelegator;
+    private readonly INavigationService _navigationService;
+    private readonly IUnderlyingThemeService _underlyingThemeService;
+    private readonly INotificationBuilder _notificationBuilder;
+    private readonly IContactService _contactService;
+
+    public CalendarSettings CurrentSettings { get; }
+    public INativeAppService NativeAppService => _nativeAppService;
+
+    [ObservableProperty]
+    public partial bool IsDarkWebviewRenderer { get; set; }
+
+    public ObservableCollection<CalendarAttachmentViewModel> Attachments { get; } = new ObservableCollection<CalendarAttachmentViewModel>();
+
+    /// <summary>
+    /// Returns true if the current event has attachments.
+    /// </summary>
+    public bool HasAttachments => Attachments.Count > 0;
+
+    #region Details
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(CanViewSeries))]
+    [NotifyPropertyChangedFor(nameof(CanEditSeries))]
+    [NotifyPropertyChangedFor(nameof(IsCurrentUserOrganizer))]
+    [NotifyPropertyChangedFor(nameof(CurrentRsvpText))]
+    [NotifyPropertyChangedFor(nameof(CurrentRsvpStatus))]
+    public partial CalendarItemViewModel CurrentEvent { get; set; }
+
+    partial void OnCurrentEventChanged(CalendarItemViewModel value)
+    {
+        // Notify the view to re-render the description
+        Messenger.Send(new CalendarDescriptionRenderingRequested());
+    }
+
+    [ObservableProperty]
+    public partial CalendarItemViewModel SeriesParent { get; set; }
+    [ObservableProperty]
+    public partial List<Reminder> Reminders { get; set; }
+
+    public ObservableCollection<ReminderOption> ReminderOptions { get; } = new ObservableCollection<ReminderOption>();
+
+    /// <summary>
+    /// Returns true if the event is part of a recurring series (as a child occurrence).
+    /// Used to enable "View Series" functionality.
+    /// </summary>
+    public bool CanViewSeries => CurrentEvent?.IsRecurringChild ?? false;
+
+    /// <summary>
+    /// Returns true if the "Edit Series" button should be visible.
+    /// Only visible for child occurrences of recurring events, not for master events or single events.
+    /// </summary>
+    public bool CanEditSeries => CurrentEvent?.IsRecurringChild ?? false;
+
+    /// <summary>
+    /// Returns true if the current user is the organizer of the event.
+    /// Used to determine if the user can invite attendees or modify the event.
+    /// </summary>
+    public bool IsCurrentUserOrganizer => CurrentEvent?.Attendees?.Any(a => a.IsOrganizer) ?? true;
+
+    #endregion
+
+    #region Show As Options
+
+    public ObservableCollection<ShowAsOption> ShowAsOptions { get; } = new ObservableCollection<ShowAsOption>();
+
+    [ObservableProperty]
+    public partial ShowAsOption SelectedShowAsOption { get; set; }
+
+    #endregion
+
+    #region RSVP Panel
+
+    [ObservableProperty]
+    public partial bool IsRsvpPanelVisible { get; set; }
+
+    public bool IncludeRsvpMessage => !string.IsNullOrEmpty(RsvpMessage);
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(IncludeRsvpMessage))]
+    public partial string RsvpMessage { get; set; } = string.Empty;
+
+    public ObservableCollection<RsvpStatusOption> RsvpStatusOptions { get; } = new ObservableCollection<RsvpStatusOption>();
+
+    public CalendarItemStatus CurrentRsvpStatus
+    {
+        get
+        {
+            return CurrentEvent?.CalendarItem?.Status ?? CalendarItemStatus.NotResponded;
+        }
+    }
+
+    public string CurrentRsvpText
+    {
+        get
+        {
+            if (CurrentEvent?.CalendarItem == null) return Translator.CalendarEventResponse_Accept;
+
+            return CurrentEvent.CalendarItem.Status switch
+            {
+                CalendarItemStatus.Accepted => Translator.CalendarEventResponse_AcceptedResponse,
+                CalendarItemStatus.Tentative => Translator.CalendarEventResponse_TentativeResponse,
+                CalendarItemStatus.Cancelled => Translator.CalendarEventResponse_DeclinedResponse,
+                CalendarItemStatus.NotResponded => Translator.CalendarEventResponse_NotResponded,
+                _ => Translator.CalendarEventResponse_NotResponded
+            };
+        }
+    }
+
+    #endregion
+
+    public EventDetailsPageViewModel(ICalendarService calendarService,
+                                     INativeAppService nativeAppService,
+                                     IPreferencesService preferencesService,
+                                     IMailDialogService dialogService,
+                                     IWinoRequestDelegator winoRequestDelegator,
+                                     INavigationService navigationService,
+                                     INotificationBuilder notificationBuilder,
+                                     IUnderlyingThemeService underlyingThemeService,
+                                     IContactService contactService)
+    {
+        _calendarService = calendarService;
+        _nativeAppService = nativeAppService;
+        _preferencesService = preferencesService;
+        _dialogService = dialogService;
+        _winoRequestDelegator = winoRequestDelegator;
+        _navigationService = navigationService;
+        _underlyingThemeService = underlyingThemeService;
+        _notificationBuilder = notificationBuilder;
+        _contactService = contactService;
+
+        CurrentSettings = _preferencesService.GetCurrentCalendarSettings();
+        IsDarkWebviewRenderer = _underlyingThemeService.IsUnderlyingThemeDark();
+
+        foreach (var showAs in CalendarItemActionOptions.ShowAsOptions)
+        {
+            ShowAsOptions.Add(new ShowAsOption(showAs));
+        }
+
+        SelectedShowAsOption = ShowAsOptions.FirstOrDefault(option => option.ShowAs == CalendarItemShowAs.Busy) ?? ShowAsOptions.FirstOrDefault();
+
+        foreach (var responseStatus in CalendarItemActionOptions.ResponseOptions)
+        {
+            RsvpStatusOptions.Add(new RsvpStatusOption(responseStatus));
+        }
+    }
+
+    public override async void OnNavigatedTo(NavigationMode mode, object parameters)
+    {
+        base.OnNavigatedTo(mode, parameters);
+
+        if (parameters == null || parameters is not CalendarItemTarget args)
+            return;
+
+        await LoadCalendarItemTargetAsync(args);
+    }
+
+    protected override async void OnCalendarItemUpdated(CalendarItem calendarItem, EntityUpdateSource source)
+    {
+        base.OnCalendarItemUpdated(calendarItem, source);
+
+        // If the current event was updated, reload it
+        if (IsCurrentEventMatch(calendarItem))
+        {
+            // Reflect client-side optimistic changes immediately; fallback to DB for server updates.
+            if (source == EntityUpdateSource.ClientUpdated || source == EntityUpdateSource.ClientReverted)
+            {
+                var previousAttendees = CurrentEvent?.Attendees?.ToList() ?? [];
+                CurrentEvent = new CalendarItemViewModel(calendarItem)
+                {
+                    IsBusy = source == EntityUpdateSource.ClientUpdated
+                };
+
+                foreach (var attendee in previousAttendees)
+                {
+                    CurrentEvent.Attendees.Add(attendee);
+                }
+
+                return;
+            }
+
+            // Refresh from DB when update comes from server sync.
+            var refreshedEvent = await _calendarService.GetCalendarItemAsync(calendarItem.Id);
+            if (refreshedEvent != null)
+            {
+                CurrentEvent = new CalendarItemViewModel(refreshedEvent);
+                await LoadAttendeesAsync(refreshedEvent.Id, refreshedEvent);
+            }
+        }
+    }
+
+    protected override async void OnCalendarItemAdded(CalendarItem calendarItem, EntityUpdateSource source)
+    {
+        base.OnCalendarItemAdded(calendarItem, source);
+
+        if (!IsCurrentEventMatch(calendarItem))
+            return;
+
+        if (source == EntityUpdateSource.ClientUpdated || source == EntityUpdateSource.ClientReverted)
+        {
+            CurrentEvent = new CalendarItemViewModel(calendarItem)
+            {
+                IsBusy = source == EntityUpdateSource.ClientUpdated
+            };
+
+            return;
+        }
+
+        var refreshedEvent = await _calendarService.GetCalendarItemAsync(calendarItem.Id);
+        if (refreshedEvent != null)
+        {
+            CurrentEvent = new CalendarItemViewModel(refreshedEvent);
+            await LoadAttendeesAsync(refreshedEvent.Id, refreshedEvent);
+        }
+    }
+
+    protected override void OnCalendarItemDeleted(CalendarItem calendarItem, EntityUpdateSource source)
+    {
+        base.OnCalendarItemDeleted(calendarItem, source);
+
+        // If the current event was deleted, navigate back
+        if (IsCurrentEventMatch(calendarItem))
+        {
+            NavigateBackToCalendar(forceReload: true);
+        }
+    }
+
+    private bool IsCurrentEventMatch(CalendarItem calendarItem)
+    {
+        if (CurrentEvent?.CalendarItem == null || calendarItem == null)
+            return false;
+
+        var trackedLocalItemId = calendarItem.RemoteEventId.GetClientTrackingId();
+
+        return CurrentEvent.CalendarItem.Id == calendarItem.Id ||
+               (trackedLocalItemId.HasValue && CurrentEvent.CalendarItem.Id == trackedLocalItemId.Value) ||
+               CurrentEvent.CalendarItem.RecurringCalendarItemId == calendarItem.Id;
+    }
+
+    private async Task LoadCalendarItemTargetAsync(CalendarItemTarget target)
+    {
+        try
+        {
+            var currentEventItem = await _calendarService.GetCalendarItemTargetAsync(target);
+
+            if (currentEventItem == null)
+                return;
+
+            CurrentEvent = new CalendarItemViewModel(currentEventItem);
+
+            await LoadAttendeesAsync(currentEventItem.Id, currentEventItem);
+
+            // Initialize SelectedShowAsOption based on current event's ShowAs
+            SelectedShowAsOption = ShowAsOptions.FirstOrDefault(o => o.ShowAs == currentEventItem.ShowAs) ?? ShowAsOptions[2];
+
+            // Load reminders for this calendar item
+            Reminders = await _calendarService.GetRemindersAsync(currentEventItem.Id);
+            InitializeReminderOptions();
+
+            // Load attachments
+            await LoadAttachmentsAsync(currentEventItem.Id);
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine(ex.Message);
+        }
+    }
+
+    private async Task LoadAttendeesAsync(Guid calendarItemId, CalendarItem calendarItem)
+    {
+        var attendees = await _calendarService.GetAttendeesAsync(calendarItemId);
+
+        // Resolve contacts for all attendees in a single batch DB query.
+        var emails = attendees
+            .Where(a => !string.IsNullOrEmpty(a.Email))
+            .Select(a => a.Email)
+            .ToList();
+
+        if (!string.IsNullOrEmpty(calendarItem.OrganizerEmail))
+            emails.Add(calendarItem.OrganizerEmail);
+
+        var contacts = await _contactService.GetContactsByAddressesAsync(emails).ConfigureAwait(false);
+        var contactLookup = contacts.ToDictionary(c => c.Address, StringComparer.OrdinalIgnoreCase);
+
+        foreach (var attendee in attendees)
+        {
+            if (!string.IsNullOrEmpty(attendee.Email) && contactLookup.TryGetValue(attendee.Email, out var contact))
+                attendee.ResolvedContact = contact;
+        }
+
+        // Separate organizer from other attendees to ensure organizer is always first
+        var organizer = attendees.FirstOrDefault(a => a.IsOrganizer);
+        var nonOrganizerAttendees = attendees.Where(a => !a.IsOrganizer).ToList();
+
+        var attendeesForUi = new List<CalendarEventAttendee>();
+
+        // If the organizer is in the list, add them first
+        if (organizer != null)
+        {
+            attendeesForUi.Add(organizer);
+        }
+        else if (!string.IsNullOrEmpty(calendarItem.OrganizerEmail))
+        {
+            // If the organizer is not in the attendees list, create and add them first
+            var organizerAttendee = new CalendarEventAttendee
+            {
+                Id = Guid.NewGuid(),
+                CalendarItemId = calendarItem.Id,
+                Name = calendarItem.OrganizerDisplayName ?? calendarItem.OrganizerEmail,
+                Email = calendarItem.OrganizerEmail,
+                IsOrganizer = true,
+                AttendenceStatus = AttendeeStatus.Accepted
+            };
+
+            if (contactLookup.TryGetValue(calendarItem.OrganizerEmail, out var organizerContact))
+                organizerAttendee.ResolvedContact = organizerContact;
+
+            attendeesForUi.Add(organizerAttendee);
+        }
+
+        // Add all other attendees after the organizer
+        foreach (var item in nonOrganizerAttendees)
+        {
+            attendeesForUi.Add(item);
+        }
+
+        await ExecuteUIThread(() =>
+        {
+            if (CurrentEvent == null)
+                return;
+
+            CurrentEvent.Attendees.Clear();
+
+            foreach (var attendee in attendeesForUi)
+            {
+                CurrentEvent.Attendees.Add(attendee);
+            }
+        });
+    }
+
+    private async Task LoadAttachmentsAsync(Guid calendarItemId)
+    {
+        Attachments.Clear();
+
+        try
+        {
+            var attachments = await _calendarService.GetAttachmentsAsync(calendarItemId);
+
+            foreach (var attachment in attachments)
+            {
+                Attachments.Add(new CalendarAttachmentViewModel(attachment));
+            }
+
+            OnPropertyChanged(nameof(HasAttachments));
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine($"Error loading attachments: {ex.Message}");
+        }
+    }
+
+    private void InitializeReminderOptions()
+    {
+        ReminderOptions.Clear();
+
+        // Add predefined options from service
+        var predefinedMinutes = _calendarService.GetPredefinedReminderMinutes();
+        var predefinedOptions = predefinedMinutes.Select(m => new ReminderOption(m)).ToList();
+
+        // Add custom reminders from synced data
+        if (Reminders != null)
+        {
+            foreach (var reminder in Reminders)
+            {
+                // Convert seconds to minutes
+                var minutesDiff = (int)(reminder.DurationInSeconds / 60);
+
+                // Check if this is a custom value not in predefined list
+                if (!predefinedMinutes.Contains(minutesDiff))
+                {
+                    predefinedOptions.Add(new ReminderOption(minutesDiff, isCustom: true));
+                }
+            }
+        }
+
+        // Sort by minutes descending and add to collection
+        foreach (var option in predefinedOptions.OrderByDescending(o => o.Minutes))
+        {
+            ReminderOptions.Add(option);
+        }
+
+        // Set selected state based on current reminders
+        if (Reminders != null)
+        {
+            foreach (var reminder in Reminders)
+            {
+                // Convert seconds to minutes
+                var minutesDiff = (int)(reminder.DurationInSeconds / 60);
+
+                var matchingOption = ReminderOptions.FirstOrDefault(o => o.Minutes == minutesDiff);
+                matchingOption?.IsSelected = true;
+            }
+        }
+    }
+
+
+    [RelayCommand]
+    private async Task SaveAsync()
+    {
+        if (CurrentEvent == null) return;
+        if (CurrentEvent.AssignedCalendar?.IsReadOnly == true)
+        {
+            _dialogService.ShowReadOnlyCalendarMessage();
+            return;
+        }
+
+        try
+        {
+            // Capture original state BEFORE making any changes for potential revert
+            var originalItem = await _calendarService.GetCalendarItemAsync(CurrentEvent.CalendarItem.Id);
+            var originalAttendees = await _calendarService.GetAttendeesAsync(CurrentEvent.CalendarItem.Id);
+
+            // Get selected reminder options
+            var selectedOptions = ReminderOptions.Where(o => o.IsSelected).ToList();
+
+            // Create separate Reminder entities for each selected option
+            var newReminders = new List<Reminder>();
+
+            foreach (var option in selectedOptions)
+            {
+                var durationInSeconds = option.Minutes * 60; // Convert minutes to seconds
+
+                newReminders.Add(new Reminder
+                {
+                    Id = Guid.NewGuid(),
+                    CalendarItemId = CurrentEvent.Id,
+                    DurationInSeconds = durationInSeconds,
+                    ReminderType = CalendarItemReminderType.Popup
+                });
+            }
+
+            // Save reminders to database
+            await _calendarService.SaveRemindersAsync(CurrentEvent.CalendarItem.Id, newReminders);
+            Reminders = newReminders;
+
+            // Update ShowAs if changed
+            if (SelectedShowAsOption != null)
+            {
+                CurrentEvent.CalendarItem.ShowAs = SelectedShowAsOption.ShowAs;
+            }
+
+            // Update the calendar item and attendees in database
+            await _calendarService.UpdateCalendarItemAsync(CurrentEvent.CalendarItem, CurrentEvent.Attendees.ToList());
+
+            // Queue the update request to synchronizer with original state for revert capability
+            var preparationRequest = new CalendarOperationPreparationRequest(
+                CalendarSynchronizerOperation.UpdateEvent,
+                CurrentEvent.CalendarItem,
+                CurrentEvent.Attendees.ToList(),
+                ResponseMessage: null,
+                OriginalItem: originalItem,
+                OriginalAttendees: originalAttendees);
+
+            await _winoRequestDelegator.ExecuteAsync(preparationRequest);
+
+            NavigateBackToCalendar(forceReload: true);
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine($"Error saving event: {ex.Message}");
+            _dialogService.InfoBarMessage(
+                Translator.Info_AttachmentSaveFailedTitle,
+                ex.Message,
+                InfoBarMessageType.Error);
+        }
+    }
+
+    [RelayCommand]
+    private async Task DeleteAsync()
+    {
+        if (CurrentEvent == null) return;
+        if (CurrentEvent.AssignedCalendar?.IsReadOnly == true)
+        {
+            _dialogService.ShowReadOnlyCalendarMessage();
+            return;
+        }
+
+        // If the event is a master recurring event, ask for confirmation
+        if (CurrentEvent.IsRecurringParent)
+        {
+            var confirmed = await _dialogService.ShowConfirmationDialogAsync(
+                Translator.DialogMessage_DeleteRecurringSeriesMessage,
+                Translator.DialogMessage_DeleteRecurringSeriesTitle,
+                Translator.Buttons_Delete);
+
+            if (!confirmed) return;
+        }
+
+        try
+        {
+            var preparationRequest = new CalendarOperationPreparationRequest(
+                CalendarSynchronizerOperation.DeleteEvent,
+                CurrentEvent.CalendarItem,
+                null);
+
+            await _winoRequestDelegator.ExecuteAsync(preparationRequest);
+
+            NavigateBackToCalendar(forceReload: true);
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine($"Error deleting calendar event: {ex.Message}");
+        }
+    }
+
+    private void NavigateBackToCalendar(bool forceReload)
+    {
+        var navigationDate = CurrentEvent?.CalendarItem.LocalStartDate ?? DateTime.Now;
+
+        _navigationService.Navigate(
+            WinoPage.CalendarPage,
+            new CalendarPageNavigationArgs
+            {
+                NavigationDate = navigationDate,
+                ForceReload = forceReload
+            });
+    }
+
+    public override async Task KeyboardShortcutHook(KeyboardShortcutTriggerDetails args)
+    {
+        if (args.Handled || args.Mode != WinoApplicationMode.Calendar || args.Action != KeyboardShortcutAction.Delete)
+            return;
+
+        await DeleteAsync();
+        args.Handled = true;
+    }
+
+    [RelayCommand]
+    private Task JoinOnlineAsync()
+    {
+        if (CurrentEvent == null || string.IsNullOrEmpty(CurrentEvent.CalendarItem.HtmlLink))
+            return Task.CompletedTask;
+
+        return _nativeAppService.LaunchUriAsync(new Uri(CurrentEvent.CalendarItem.HtmlLink));
+    }
+
+    [RelayCommand]
+    private Task CreateTestNotificationAsync()
+    {
+        if (CurrentEvent?.CalendarItem == null)
+            return Task.CompletedTask;
+
+        var reminderDurationInSeconds = Reminders?
+            .Where(x => x.DurationInSeconds > 0)
+            .OrderByDescending(x => x.DurationInSeconds)
+            .Select(x => x.DurationInSeconds)
+            .FirstOrDefault() ?? 0;
+
+        if (reminderDurationInSeconds <= 0)
+            reminderDurationInSeconds = Math.Max(_preferencesService.DefaultReminderDurationInSeconds, 30 * 60);
+
+        return _notificationBuilder.CreateCalendarReminderNotificationAsync(CurrentEvent.CalendarItem, reminderDurationInSeconds);
+    }
+
+    [RelayCommand]
+    private void ToggleRsvpPanel()
+    {
+        IsRsvpPanelVisible = !IsRsvpPanelVisible;
+
+        if (IsRsvpPanelVisible && CurrentEvent?.CalendarItem != null)
+        {
+            // Initialize selection based on current status
+            foreach (var item in RsvpStatusOptions)
+            {
+                item.IsSelected = CurrentEvent?.CalendarItem?.Status == item.Status;
+            }
+        }
+    }
+
+    [RelayCommand]
+    private void CloseRsvpPanel()
+    {
+        IsRsvpPanelVisible = false;
+        RsvpMessage = string.Empty;
+    }
+
+    [RelayCommand]
+    private async Task SendRsvpResponse(AttendeeStatus status)
+    {
+        if (CurrentEvent == null) return;
+        if (CurrentEvent.AssignedCalendar?.IsReadOnly == true)
+        {
+            _dialogService.ShowReadOnlyCalendarMessage();
+            return;
+        }
+
+        try
+        {
+            // Get the optional response message if user wants to include it
+            var responseMessage = IncludeRsvpMessage ? RsvpMessage : null;
+
+            // Map status to operation
+            CalendarSynchronizerOperation operation = status switch
+            {
+                AttendeeStatus.Accepted => CalendarSynchronizerOperation.AcceptEvent,
+                AttendeeStatus.Tentative => CalendarSynchronizerOperation.TentativeEvent,
+                AttendeeStatus.Declined => CalendarSynchronizerOperation.DeclineEvent,
+                _ => throw new InvalidOperationException($"Invalid RSVP status: {status}")
+            };
+
+            // Create preparation request with the optional message
+            var preparationRequest = new CalendarOperationPreparationRequest(
+                operation,
+                CurrentEvent.CalendarItem,
+                null,
+                responseMessage);
+
+            await _winoRequestDelegator.ExecuteAsync(preparationRequest);
+
+            // Reload attendees to get the updated status from the server
+            await LoadAttendeesAsync(CurrentEvent.CalendarItem.Id, CurrentEvent.CalendarItem);
+
+            OnPropertyChanged(nameof(CurrentRsvpText));
+            OnPropertyChanged(nameof(CurrentRsvpStatus));
+
+            CloseRsvpPanel();
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine($"Error sending RSVP response: {ex.Message}");
+            _dialogService.InfoBarMessage(
+                Translator.Info_AttachmentSaveFailedTitle,
+                ex.Message,
+                InfoBarMessageType.Error);
+        }
+    }
+
+    [RelayCommand]
+    private async Task ViewSeriesAsync()
+    {
+        if (CurrentEvent == null || !CurrentEvent.IsRecurringChild) return;
+
+        try
+        {
+            // Get the master event from the recurring series
+            var masterEventId = CurrentEvent.CalendarItem.RecurringCalendarItemId.Value;
+            var masterEvent = await _calendarService.GetCalendarItemAsync(masterEventId);
+
+            if (masterEvent == null) return;
+
+            // Load the master event without navigation
+            var target = new CalendarItemTarget(masterEvent, CalendarEventTargetType.Series);
+            await LoadCalendarItemTargetAsync(target);
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine($"Error loading series: {ex.Message}");
+        }
+    }
+
+    [RelayCommand]
+    private async Task OpenAttachmentAsync(CalendarAttachmentViewModel attachmentViewModel)
+    {
+        if (attachmentViewModel == null || CurrentEvent?.CalendarItem == null) return;
+
+        try
+        {
+            attachmentViewModel.IsBusy = true;
+
+            // If not downloaded, download it first
+            if (!attachmentViewModel.IsDownloaded)
+            {
+                await DownloadAttachmentAsync(attachmentViewModel);
+            }
+
+            // Launch the file
+            if (!string.IsNullOrEmpty(attachmentViewModel.Attachment.LocalFilePath) &&
+                File.Exists(attachmentViewModel.Attachment.LocalFilePath))
+            {
+                await _nativeAppService.LaunchFileAsync(attachmentViewModel.Attachment.LocalFilePath);
+            }
+        }
+        catch (Exception ex)
+        {
+            Log.Error(ex, "Failed to open calendar attachment.");
+            _dialogService.InfoBarMessage(
+                Translator.Info_AttachmentOpenFailedTitle,
+                Translator.Info_AttachmentOpenFailedMessage,
+                InfoBarMessageType.Error);
+        }
+        finally
+        {
+            attachmentViewModel.IsBusy = false;
+        }
+    }
+
+    [RelayCommand]
+    private async Task SaveAttachmentAsync(CalendarAttachmentViewModel attachmentViewModel)
+    {
+        if (attachmentViewModel == null) return;
+
+        try
+        {
+            attachmentViewModel.IsBusy = true;
+
+            var pickedPath = await _dialogService.PickWindowsFolderAsync();
+            if (string.IsNullOrEmpty(pickedPath)) return;
+
+            // Download if not already downloaded
+            if (!attachmentViewModel.IsDownloaded)
+            {
+                await DownloadAttachmentAsync(attachmentViewModel);
+            }
+
+            // Copy to selected location
+            if (!string.IsNullOrEmpty(attachmentViewModel.Attachment.LocalFilePath) &&
+                File.Exists(attachmentViewModel.Attachment.LocalFilePath))
+            {
+                var destinationPath = Path.Combine(pickedPath, attachmentViewModel.FileName);
+                File.Copy(attachmentViewModel.Attachment.LocalFilePath, destinationPath, overwrite: true);
+
+                _dialogService.InfoBarMessage(
+                    Translator.Info_AttachmentSaveSuccessTitle,
+                    Translator.Info_AttachmentSaveSuccessMessage,
+                    InfoBarMessageType.Success);
+            }
+        }
+        catch (Exception ex)
+        {
+            Log.Error(ex, "Failed to save calendar attachment.");
+            _dialogService.InfoBarMessage(
+                Translator.Info_AttachmentSaveFailedTitle,
+                Translator.Info_AttachmentSaveFailedMessage,
+                InfoBarMessageType.Error);
+        }
+        finally
+        {
+            attachmentViewModel.IsBusy = false;
+        }
+    }
+
+    private async Task DownloadAttachmentAsync(CalendarAttachmentViewModel attachmentViewModel)
+    {
+        if (CurrentEvent?.CalendarItem == null) return;
+
+        // Create attachments folder for this calendar item
+        var attachmentsFolder = Path.Combine(
+            _nativeAppService.GetCalendarAttachmentsFolderPath(),
+            CurrentEvent.CalendarItem.Id.ToString());
+
+        Directory.CreateDirectory(attachmentsFolder);
+
+        var localFilePath = Path.Combine(attachmentsFolder, attachmentViewModel.FileName);
+
+        // Download attachment using synchronizer
+        await SynchronizationManager.Instance.DownloadCalendarAttachmentAsync(
+            CurrentEvent.CalendarItem,
+            attachmentViewModel.Attachment,
+            localFilePath);
+
+        // Mark as downloaded
+        await _calendarService.MarkAttachmentDownloadedAsync(
+            attachmentViewModel.Id,
+            localFilePath);
+
+        // Update view model
+        attachmentViewModel.Attachment.IsDownloaded = true;
+        attachmentViewModel.Attachment.LocalFilePath = localFilePath;
+        OnPropertyChanged(nameof(attachmentViewModel.IsDownloaded));
+    }
+}
+
+public partial class ReminderOption : ObservableObject
+{
+    public int Minutes { get; }
+    public bool IsCustom { get; }
+
+    [ObservableProperty]
+    public partial bool IsSelected { get; set; }
+
+    public string DisplayText
+    {
+        get
+        {
+            if (Minutes >= 60)
+            {
+                var hours = Minutes / 60;
+                return hours == 1 ? "1 Hour" : $"{hours} Hours";
+            }
+            return Minutes == 1 ? "1 Minute" : $"{Minutes} Minutes";
+        }
+    }
+
+    public ReminderOption(int minutes, bool isCustom = false)
+    {
+        Minutes = minutes;
+        IsCustom = isCustom;
+    }
+}
+
+public partial class ShowAsOption : ObservableObject
+{
+    public CalendarItemShowAs ShowAs { get; }
+
+    public string DisplayText
+    {
+        get
+        {
+            return ShowAs switch
+            {
+                CalendarItemShowAs.Free => Translator.CalendarShowAs_Free,
+                CalendarItemShowAs.Tentative => Translator.CalendarShowAs_Tentative,
+                CalendarItemShowAs.Busy => Translator.CalendarShowAs_Busy,
+                CalendarItemShowAs.OutOfOffice => Translator.CalendarShowAs_OutOfOffice,
+                CalendarItemShowAs.WorkingElsewhere => Translator.CalendarShowAs_WorkingElsewhere,
+                _ => Translator.CalendarShowAs_Busy
+            };
+        }
+    }
+
+    public ShowAsOption(CalendarItemShowAs showAs)
+    {
+        ShowAs = showAs;
+    }
+}
+
+public partial class RsvpStatusOption : ObservableObject
+{
+    public CalendarItemStatus Status { get; }
+
+    public string StatusText
+    {
+        get
+        {
+            return Status switch
+            {
+                CalendarItemStatus.Accepted => Translator.CalendarEventResponse_Accept,
+                CalendarItemStatus.Tentative => Translator.CalendarEventResponse_Tentative,
+                CalendarItemStatus.Cancelled => Translator.CalendarEventResponse_Decline,
+                _ => Translator.CalendarEventResponse_Accept
+            };
+        }
+    }
+
+    [ObservableProperty]
+    public partial bool IsSelected { get; set; }
+
+    public RsvpStatusOption(CalendarItemStatus status)
+    {
+        Status = status;
+    }
+}

Wino.Calendar.ViewModels/Interfaces/IAccountCalendarStateService.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using CommunityToolkit.Mvvm.Collections;
+using Wino.Calendar.ViewModels.Data;
+using Wino.Core.Domain.Entities.Shared;
+using Wino.Core.Domain.Interfaces;
+
+namespace Wino.Calendar.ViewModels.Interfaces;
+
+public interface IAccountCalendarStateService : INotifyPropertyChanged
+{
+    IDispatcher Dispatcher { get; set; }
+    ReadOnlyObservableCollection<GroupedAccountCalendarViewModel> GroupedAccountCalendars { get; }
+
+    event EventHandler<GroupedAccountCalendarViewModel> CollectiveAccountGroupSelectionStateChanged;
+    event EventHandler<AccountCalendarViewModel> AccountCalendarSelectionStateChanged;
+
+    public void AddGroupedAccountCalendar(GroupedAccountCalendarViewModel groupedAccountCalendar);
+    public void RemoveGroupedAccountCalendar(GroupedAccountCalendarViewModel groupedAccountCalendar);
+    public void ClearGroupedAccountCalendars();
+
+    public void AddAccountCalendar(AccountCalendarViewModel accountCalendar);
+    public void RemoveAccountCalendar(AccountCalendarViewModel accountCalendar);
+
+    /// <summary>
+    /// Enumeration of currently selected calendars.
+    /// </summary>
+    IEnumerable<AccountCalendarViewModel> ActiveCalendars { get; }
+    IEnumerable<AccountCalendarViewModel> AllCalendars { get; }
+    bool IsAnySynchronizationInProgress { get; }
+    ReadOnlyObservableGroupedCollection<MailAccount, AccountCalendarViewModel> GroupedCalendars { get; set; }
+}

Wino.Calendar.ViewModels/Messages/CalendarItemContextActionRequestedMessage.cs

@@ -0,0 +1,8 @@
+using Wino.Calendar.ViewModels.Data;
+using Wino.Core.Domain.Models.Calendar;
+
+namespace Wino.Calendar.ViewModels.Messages;
+
+public sealed record CalendarItemContextActionRequestedMessage(
+    CalendarItemViewModel CalendarItemViewModel,
+    CalendarContextMenuAction Action);

Wino.Calendar.ViewModels/Messages/CalendarItemDoubleTappedMessage.cs

@@ -0,0 +1,13 @@
+using Wino.Calendar.ViewModels.Data;
+
+namespace Wino.Calendar.ViewModels.Messages;
+
+public class CalendarItemDoubleTappedMessage
+{
+    public CalendarItemDoubleTappedMessage(CalendarItemViewModel calendarItemViewModel)
+    {
+        CalendarItemViewModel = calendarItemViewModel;
+    }
+
+    public CalendarItemViewModel CalendarItemViewModel { get; }
+}

Wino.Calendar.ViewModels/Messages/CalendarItemRightTappedMessage.cs

@@ -0,0 +1,13 @@
+using Wino.Calendar.ViewModels.Data;
+
+namespace Wino.Calendar.ViewModels.Messages;
+
+public class CalendarItemRightTappedMessage
+{
+    public CalendarItemRightTappedMessage(CalendarItemViewModel calendarItemViewModel)
+    {
+        CalendarItemViewModel = calendarItemViewModel;
+    }
+
+    public CalendarItemViewModel CalendarItemViewModel { get; }
+}

Wino.Calendar.ViewModels/Messages/CalendarItemTappedMessage.cs

@@ -0,0 +1,12 @@
+using Wino.Calendar.ViewModels.Data;
+namespace Wino.Calendar.ViewModels.Messages;
+
+public class CalendarItemTappedMessage
+{
+    public CalendarItemTappedMessage(CalendarItemViewModel calendarItemViewModel)
+    {
+        CalendarItemViewModel = calendarItemViewModel;
+    }
+
+    public CalendarItemViewModel CalendarItemViewModel { get; }
+}

Wino.Calendar.ViewModels/Wino.Calendar.ViewModels.csproj

@@ -0,0 +1,25 @@
+<Project Sdk="Microsoft.NET.Sdk">
+	<PropertyGroup>
+		<TargetFramework>net10.0</TargetFramework>
+		<Platforms>x86;x64;arm64</Platforms>
+		<RuntimeIdentifiers>win-x86;win-x64;win-arm64</RuntimeIdentifiers>
+		<AccelerateBuildsInVisualStudio>true</AccelerateBuildsInVisualStudio>
+		<ProduceReferenceAssembly>true</ProduceReferenceAssembly>
+		<IsTrimmable>true</IsTrimmable>
+		<EnableTrimAnalyzer>true</EnableTrimAnalyzer>
+		<TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+	</PropertyGroup>
+	<ItemGroup>
+		<PackageReference Include="TimePeriodLibrary.NET" />
+		<PackageReference Include="EmailValidation" />
+	</ItemGroup>
+
+	<ItemGroup>
+	  <ProjectReference Include="..\Wino.Core.Domain\Wino.Core.Domain.csproj" />
+	  <ProjectReference Include="..\Wino.Core.ViewModels\Wino.Core.ViewModels.csproj" />
+	  <ProjectReference Include="..\Wino.Core\Wino.Core.csproj" />
+	  <ProjectReference Include="..\Wino.Messages\Wino.Messaging.csproj" />
+	  <ProjectReference Include="..\Wino.Services\Wino.Services.csproj" />
+	</ItemGroup>
+
+</Project>

Wino.Calendar/App.xaml

@@ -1,7 +0,0 @@
-<Application
-    x:Class="Wino.Calendar.App"
-    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
-    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-    xmlns:local="using:Wino.Calendar">
-
-</Application>

Wino.Calendar/App.xaml.cs

@@ -1,100 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Runtime.InteropServices.WindowsRuntime;
-using Windows.ApplicationModel;
-using Windows.ApplicationModel.Activation;
-using Windows.Foundation;
-using Windows.Foundation.Collections;
-using Windows.UI.Xaml;
-using Windows.UI.Xaml.Controls;
-using Windows.UI.Xaml.Controls.Primitives;
-using Windows.UI.Xaml.Data;
-using Windows.UI.Xaml.Input;
-using Windows.UI.Xaml.Media;
-using Windows.UI.Xaml.Navigation;
-
-namespace Wino.Calendar
-{
-    /// <summary>
-    /// Provides application-specific behavior to supplement the default Application class.
-    /// </summary>
-    sealed partial class App : Application
-    {
-        /// <summary>
-        /// Initializes the singleton application object.  This is the first line of authored code
-        /// executed, and as such is the logical equivalent of main() or WinMain().
-        /// </summary>
-        public App()
-        {
-            this.InitializeComponent();
-            this.Suspending += OnSuspending;
-        }
-
-        /// <summary>
-        /// Invoked when the application is launched normally by the end user.  Other entry points
-        /// will be used such as when the application is launched to open a specific file.
-        /// </summary>
-        /// <param name="e">Details about the launch request and process.</param>
-        protected override void OnLaunched(LaunchActivatedEventArgs e)
-        {
-            Frame rootFrame = Window.Current.Content as Frame;
-
-            // Do not repeat app initialization when the Window already has content,
-            // just ensure that the window is active
-            if (rootFrame == null)
-            {
-                // Create a Frame to act as the navigation context and navigate to the first page
-                rootFrame = new Frame();
-
-                rootFrame.NavigationFailed += OnNavigationFailed;
-
-                if (e.PreviousExecutionState == ApplicationExecutionState.Terminated)
-                {
-                    //TODO: Load state from previously suspended application
-                }
-
-                // Place the frame in the current Window
-                Window.Current.Content = rootFrame;
-            }
-
-            if (e.PrelaunchActivated == false)
-            {
-                if (rootFrame.Content == null)
-                {
-                    // When the navigation stack isn't restored navigate to the first page,
-                    // configuring the new page by passing required information as a navigation
-                    // parameter
-                    rootFrame.Navigate(typeof(MainPage), e.Arguments);
-                }
-                // Ensure the current window is active
-                Window.Current.Activate();
-            }
-        }
-
-        /// <summary>
-        /// Invoked when Navigation to a certain page fails
-        /// </summary>
-        /// <param name="sender">The Frame which failed navigation</param>
-        /// <param name="e">Details about the navigation failure</param>
-        void OnNavigationFailed(object sender, NavigationFailedEventArgs e)
-        {
-            throw new Exception("Failed to load Page " + e.SourcePageType.FullName);
-        }
-
-        /// <summary>
-        /// Invoked when application execution is being suspended.  Application state is saved
-        /// without knowing whether the application will be terminated or resumed with the contents
-        /// of memory still intact.
-        /// </summary>
-        /// <param name="sender">The source of the suspend request.</param>
-        /// <param name="e">Details about the suspend request.</param>
-        private void OnSuspending(object sender, SuspendingEventArgs e)
-        {
-            var deferral = e.SuspendingOperation.GetDeferral();
-            //TODO: Save application state and stop any background activity
-            deferral.Complete();
-        }
-    }
-}

Wino.Calendar/MainPage.xaml

@@ -1,14 +0,0 @@
-<Page
-    x:Class="Wino.Calendar.MainPage"
-    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
-    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-    xmlns:local="using:Wino.Calendar"
-    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
-    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
-    mc:Ignorable="d"
-    Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
-
-    <Grid>
-
-    </Grid>
-</Page>

Wino.Calendar/MainPage.xaml.cs

@@ -1,30 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Runtime.InteropServices.WindowsRuntime;
-using Windows.Foundation;
-using Windows.Foundation.Collections;
-using Windows.UI.Xaml;
-using Windows.UI.Xaml.Controls;
-using Windows.UI.Xaml.Controls.Primitives;
-using Windows.UI.Xaml.Data;
-using Windows.UI.Xaml.Input;
-using Windows.UI.Xaml.Media;
-using Windows.UI.Xaml.Navigation;
-
-// The Blank Page item template is documented at https://go.microsoft.com/fwlink/?LinkId=402352&clcid=0x409
-
-namespace Wino.Calendar
-{
-    /// <summary>
-    /// An empty page that can be used on its own or navigated to within a Frame.
-    /// </summary>
-    public sealed partial class MainPage : Page
-    {
-        public MainPage()
-        {
-            this.InitializeComponent();
-        }
-    }
-}

Wino.Calendar/Package.appxmanifest

@@ -1,58 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-
-<Package
-  xmlns="http://schemas.microsoft.com/appx/manifest/foundation/windows10"
-  xmlns:mp="http://schemas.microsoft.com/appx/2014/phone/manifest"
-  xmlns:uap="http://schemas.microsoft.com/appx/manifest/uap/windows10"
-  IgnorableNamespaces="uap mp">
-
-	<!-- Publisher Cache Folders -->
-	<Extensions>
-		<Extension Category="windows.publisherCacheFolders">
-			<PublisherCacheFolders>
-				<Folder Name="WinoShared" />
-			</PublisherCacheFolders>
-		</Extension>
-	</Extensions>
-	
-  <Identity
-    Name="58272BurakKSE.WinoCalendar"
-    Publisher="CN=51FBDAF3-E212-4149-89A2-A2636B3BC911"
-    Version="1.0.0.0" />
-
-  <mp:PhoneIdentity PhoneProductId="f047b7dd-96ec-4d54-a862-9321e271e449" PhonePublisherId="00000000-0000-0000-0000-000000000000"/>
-
-  <Properties>
-    <DisplayName>Wino Calendar</DisplayName>
-    <PublisherDisplayName>Burak KÖSE</PublisherDisplayName>
-    <Logo>Assets\StoreLogo.png</Logo>
-  </Properties>
-
-  <Dependencies>
-    <TargetDeviceFamily Name="Windows.Universal" MinVersion="10.0.0.0" MaxVersionTested="10.0.0.0" />
-  </Dependencies>
-
-  <Resources>
-    <Resource Language="x-generate"/>
-  </Resources>
-
-  <Applications>
-    <Application Id="App"
-      Executable="$targetnametoken$.exe"
-      EntryPoint="Wino.Calendar.App">
-      <uap:VisualElements
-        DisplayName="Wino Calendar"
-        Square150x150Logo="Assets\Square150x150Logo.png"
-        Square44x44Logo="Assets\Square44x44Logo.png"
-        Description="Wino.Calendar"
-        BackgroundColor="transparent">
-        <uap:DefaultTile Wide310x150Logo="Assets\Wide310x150Logo.png"/>
-        <uap:SplashScreen Image="Assets\SplashScreen.png" />
-      </uap:VisualElements>
-    </Application>
-  </Applications>
-
-  <Capabilities>
-    <Capability Name="internetClient" />
-  </Capabilities>
-</Package>

Wino.Calendar/Properties/AssemblyInfo.cs

@@ -1,29 +0,0 @@
-using System.Reflection;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-
-// General Information about an assembly is controlled through the following 
-// set of attributes. Change these attribute values to modify the information
-// associated with an assembly.
-[assembly: AssemblyTitle("Wino.Calendar")]
-[assembly: AssemblyDescription("")]
-[assembly: AssemblyConfiguration("")]
-[assembly: AssemblyCompany("")]
-[assembly: AssemblyProduct("Wino.Calendar")]
-[assembly: AssemblyCopyright("Copyright ©  2023")]
-[assembly: AssemblyTrademark("")]
-[assembly: AssemblyCulture("")]
-
-// Version information for an assembly consists of the following four values:
-//
-//      Major Version
-//      Minor Version 
-//      Build Number
-//      Revision
-//
-// You can specify all the values or you can default the Build and Revision Numbers 
-// by using the '*' as shown below:
-// [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]
-[assembly: ComVisible(false)]

Wino.Calendar/Properties/Default.rd.xml

@@ -1,31 +0,0 @@
-<!--
-    This file contains Runtime Directives used by .NET Native. The defaults here are suitable for most
-    developers. However, you can modify these parameters to modify the behavior of the .NET Native
-    optimizer.
-
-    Runtime Directives are documented at https://go.microsoft.com/fwlink/?LinkID=391919
-
-    To fully enable reflection for App1.MyClass and all of its public/private members
-    <Type Name="App1.MyClass" Dynamic="Required All"/>
-
-    To enable dynamic creation of the specific instantiation of AppClass<T> over System.Int32
-    <TypeInstantiation Name="App1.AppClass" Arguments="System.Int32" Activate="Required Public" />
-
-    Using the Namespace directive to apply reflection policy to all the types in a particular namespace
-    <Namespace Name="DataClasses.ViewModels" Serialize="All" />
--->
-
-<Directives xmlns="http://schemas.microsoft.com/netfx/2013/01/metadata">
-  <Application>
-    <!--
-      An Assembly element with Name="*Application*" applies to all assemblies in
-      the application package. The asterisks are not wildcards.
-    -->
-    <Assembly Name="*Application*" Dynamic="Required All" />
-    
-    
-    <!-- Add your application specific runtime directives here. -->
-
-
-  </Application>
-</Directives>

Wino.Calendar/Wino.Calendar.csproj

@@ -1,172 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
-    <ProjectGuid>{600F4979-DB7E-409D-B7DA-B60BE4C55C35}</ProjectGuid>
-    <OutputType>AppContainerExe</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>Wino.Calendar</RootNamespace>
-    <AssemblyName>Wino.Calendar</AssemblyName>
-    <DefaultLanguage>en-US</DefaultLanguage>
-    <TargetPlatformIdentifier>UAP</TargetPlatformIdentifier>
-    <TargetPlatformVersion Condition=" '$(TargetPlatformVersion)' == '' ">10.0.22621.0</TargetPlatformVersion>
-    <TargetPlatformMinVersion>10.0.17763.0</TargetPlatformMinVersion>
-    <MinimumVisualStudioVersion>14</MinimumVisualStudioVersion>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{A5A43C5B-DE2A-4C0C-9213-0A381AF9435A};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <WindowsXamlEnableOverview>true</WindowsXamlEnableOverview>
-    <AppxPackageSigningEnabled>True</AppxPackageSigningEnabled>
-    <PackageCertificateThumbprint>125A5273FCFE8D551C3FED87F67C87A663E98F1B</PackageCertificateThumbprint>
-    <PackageCertificateKeyFile />
-    <GenerateTemporaryStoreCertificate>True</GenerateTemporaryStoreCertificate>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
-    <DebugSymbols>true</DebugSymbols>
-    <OutputPath>bin\x86\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
-    <NoWarn>;2008</NoWarn>
-    <DebugType>full</DebugType>
-    <PlatformTarget>x86</PlatformTarget>
-    <UseVSHostingProcess>false</UseVSHostingProcess>
-    <ErrorReport>prompt</ErrorReport>
-    <Prefer32Bit>true</Prefer32Bit>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x86'">
-    <OutputPath>bin\x86\Release\</OutputPath>
-    <DefineConstants>TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
-    <Optimize>true</Optimize>
-    <NoWarn>;2008</NoWarn>
-    <DebugType>pdbonly</DebugType>
-    <PlatformTarget>x86</PlatformTarget>
-    <UseVSHostingProcess>false</UseVSHostingProcess>
-    <ErrorReport>prompt</ErrorReport>
-    <Prefer32Bit>true</Prefer32Bit>
-    <UseDotNetNativeToolchain>true</UseDotNetNativeToolchain>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|ARM'">
-    <DebugSymbols>true</DebugSymbols>
-    <OutputPath>bin\ARM\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
-    <NoWarn>;2008</NoWarn>
-    <DebugType>full</DebugType>
-    <PlatformTarget>ARM</PlatformTarget>
-    <UseVSHostingProcess>false</UseVSHostingProcess>
-    <ErrorReport>prompt</ErrorReport>
-    <Prefer32Bit>true</Prefer32Bit>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|ARM'">
-    <OutputPath>bin\ARM\Release\</OutputPath>
-    <DefineConstants>TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
-    <Optimize>true</Optimize>
-    <NoWarn>;2008</NoWarn>
-    <DebugType>pdbonly</DebugType>
-    <PlatformTarget>ARM</PlatformTarget>
-    <UseVSHostingProcess>false</UseVSHostingProcess>
-    <ErrorReport>prompt</ErrorReport>
-    <Prefer32Bit>true</Prefer32Bit>
-    <UseDotNetNativeToolchain>true</UseDotNetNativeToolchain>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|ARM64'">
-    <DebugSymbols>true</DebugSymbols>
-    <OutputPath>bin\ARM64\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
-    <NoWarn>;2008</NoWarn>
-    <DebugType>full</DebugType>
-    <PlatformTarget>ARM64</PlatformTarget>
-    <UseVSHostingProcess>false</UseVSHostingProcess>
-    <ErrorReport>prompt</ErrorReport>
-    <Prefer32Bit>true</Prefer32Bit>
-    <UseDotNetNativeToolchain>true</UseDotNetNativeToolchain>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|ARM64'">
-    <OutputPath>bin\ARM64\Release\</OutputPath>
-    <DefineConstants>TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
-    <Optimize>true</Optimize>
-    <NoWarn>;2008</NoWarn>
-    <DebugType>pdbonly</DebugType>
-    <PlatformTarget>ARM64</PlatformTarget>
-    <UseVSHostingProcess>false</UseVSHostingProcess>
-    <ErrorReport>prompt</ErrorReport>
-    <Prefer32Bit>true</Prefer32Bit>
-    <UseDotNetNativeToolchain>true</UseDotNetNativeToolchain>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
-    <DebugSymbols>true</DebugSymbols>
-    <OutputPath>bin\x64\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
-    <NoWarn>;2008</NoWarn>
-    <DebugType>full</DebugType>
-    <PlatformTarget>x64</PlatformTarget>
-    <UseVSHostingProcess>false</UseVSHostingProcess>
-    <ErrorReport>prompt</ErrorReport>
-    <Prefer32Bit>true</Prefer32Bit>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
-    <OutputPath>bin\x64\Release\</OutputPath>
-    <DefineConstants>TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
-    <Optimize>true</Optimize>
-    <NoWarn>;2008</NoWarn>
-    <DebugType>pdbonly</DebugType>
-    <PlatformTarget>x64</PlatformTarget>
-    <UseVSHostingProcess>false</UseVSHostingProcess>
-    <ErrorReport>prompt</ErrorReport>
-    <Prefer32Bit>true</Prefer32Bit>
-    <UseDotNetNativeToolchain>true</UseDotNetNativeToolchain>
-  </PropertyGroup>
-  <PropertyGroup>
-    <RestoreProjectStyle>PackageReference</RestoreProjectStyle>
-  </PropertyGroup>
-  <ItemGroup>
-    <Compile Include="App.xaml.cs">
-      <DependentUpon>App.xaml</DependentUpon>
-    </Compile>
-    <Compile Include="MainPage.xaml.cs">
-      <DependentUpon>MainPage.xaml</DependentUpon>
-    </Compile>
-    <Compile Include="Properties\AssemblyInfo.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <AppxManifest Include="Package.appxmanifest">
-      <SubType>Designer</SubType>
-    </AppxManifest>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="Package.StoreAssociation.xml" />
-    <Content Include="Properties\Default.rd.xml" />
-    <Content Include="Assets\LockScreenLogo.scale-200.png" />
-    <Content Include="Assets\SplashScreen.scale-200.png" />
-    <Content Include="Assets\Square150x150Logo.scale-200.png" />
-    <Content Include="Assets\Square44x44Logo.scale-200.png" />
-    <Content Include="Assets\Square44x44Logo.targetsize-24_altform-unplated.png" />
-    <Content Include="Assets\StoreLogo.png" />
-    <Content Include="Assets\Wide310x150Logo.scale-200.png" />
-  </ItemGroup>
-  <ItemGroup>
-    <ApplicationDefinition Include="App.xaml">
-      <Generator>MSBuild:Compile</Generator>
-      <SubType>Designer</SubType>
-    </ApplicationDefinition>
-    <Page Include="MainPage.xaml">
-      <Generator>MSBuild:Compile</Generator>
-      <SubType>Designer</SubType>
-    </Page>
-  </ItemGroup>
-  <ItemGroup>
-    <PackageReference Include="Microsoft.NETCore.UniversalWindowsPlatform">
-      <Version>6.2.14</Version>
-    </PackageReference>
-  </ItemGroup>
-  <PropertyGroup Condition=" '$(VisualStudioVersion)' == '' or '$(VisualStudioVersion)' &lt; '14.0' ">
-    <VisualStudioVersion>14.0</VisualStudioVersion>
-  </PropertyGroup>
-  <Import Project="$(MSBuildExtensionsPath)\Microsoft\WindowsXaml\v$(VisualStudioVersion)\Microsoft.Windows.UI.Xaml.CSharp.targets" />
-  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
-       Other similar extension points exist, see Microsoft.Common.targets.
-  <Target Name="BeforeBuild">
-  </Target>
-  <Target Name="AfterBuild">
-  </Target>
-  -->
-</Project>

Wino.Core.Domain/AppUrls.cs

@@ -0,0 +1,10 @@
+namespace Wino.Core.Domain;
+
+public static class AppUrls
+{
+    public const string Website = "https://www.winomail.app";
+    public const string Discord = "https://discord.gg/windows-apps-hub-714581497222398064";
+    public const string GitHub = "https://github.com/bkaankose/Wino-Mail/";
+    public const string PrivacyPolicy = "https://www.winomail.app/support/privacy";
+    public const string Paypal = "https://paypal.me/bkaankose?country.x=PL&locale.x=en_US";
+}

Wino.Core.Domain/BasicTypesJsonContext.cs

@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+using System.Text.Json.Serialization;
+using Wino.Core.Domain.Models.Updates;
+
+namespace Wino.Core.Domain;
+
+[JsonSerializable(typeof(Dictionary<string, string>))]
+[JsonSerializable(typeof(string))]
+[JsonSerializable(typeof(int))]
+[JsonSerializable(typeof(List<string>))]
+[JsonSerializable(typeof(bool))]
+[JsonSerializable(typeof(UpdateNotes))]
+[JsonSerializable(typeof(List<UpdateNoteSection>))]
+public partial class BasicTypesJsonContext : JsonSerializerContext;

Wino.Core.Domain/CalendarItemActionOptions.cs

@@ -0,0 +1,23 @@
+using System.Collections.Generic;
+using Wino.Core.Domain.Enums;
+
+namespace Wino.Core.Domain;
+
+public static class CalendarItemActionOptions
+{
+    public static IReadOnlyList<CalendarItemShowAs> ShowAsOptions { get; } =
+    [
+        CalendarItemShowAs.Free,
+        CalendarItemShowAs.Tentative,
+        CalendarItemShowAs.Busy,
+        CalendarItemShowAs.OutOfOffice,
+        CalendarItemShowAs.WorkingElsewhere
+    ];
+
+    public static IReadOnlyList<CalendarItemStatus> ResponseOptions { get; } =
+    [
+        CalendarItemStatus.Accepted,
+        CalendarItemStatus.Tentative,
+        CalendarItemStatus.Cancelled
+    ];
+}

Wino.Core.Domain/CalendarRecurrenceSummaryFormatter.cs

@@ -0,0 +1,126 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using Wino.Core.Domain.Enums;
+using Wino.Core.Domain.Models.Calendar;
+
+namespace Wino.Core.Domain;
+
+public static class CalendarRecurrenceSummaryFormatter
+{
+    private static readonly DayOfWeek[] OrderedDays =
+    [
+        DayOfWeek.Monday,
+        DayOfWeek.Tuesday,
+        DayOfWeek.Wednesday,
+        DayOfWeek.Thursday,
+        DayOfWeek.Friday,
+        DayOfWeek.Saturday,
+        DayOfWeek.Sunday
+    ];
+
+    public static string BuildSummary(
+        bool isRecurring,
+        DateTimeOffset effectiveStart,
+        DateTimeOffset effectiveEnd,
+        bool isAllDay,
+        CalendarSettings settings,
+        int interval,
+        CalendarItemRecurrenceFrequency frequency,
+        IReadOnlyCollection<DayOfWeek> daysOfWeek,
+        DateTimeOffset? recurrenceEndDate)
+    {
+        var culture = settings?.CultureInfo ?? CultureInfo.CurrentCulture;
+        var timeSummary = isAllDay
+            ? Translator.CalendarItemAllDay
+            : string.Format(
+                culture,
+                Translator.CalendarEventCompose_TimeRangeSummary,
+                effectiveStart.ToString(settings?.DayHeaderDisplayType == DayHeaderDisplayType.TwentyFourHour ? "HH:mm" : "h:mm tt", culture),
+                effectiveEnd.ToString(settings?.DayHeaderDisplayType == DayHeaderDisplayType.TwentyFourHour ? "HH:mm" : "h:mm tt", culture));
+
+        if (!isRecurring)
+        {
+            return string.Format(
+                culture,
+                Translator.CalendarEventCompose_SingleOccurrenceSummary,
+                effectiveStart.ToString("dddd yyyy-MM-dd", culture),
+                timeSummary);
+        }
+
+        var normalizedDays = NormalizeDays(daysOfWeek);
+        var isEveryDay = (frequency == CalendarItemRecurrenceFrequency.Daily && interval == 1) ||
+                         (frequency == CalendarItemRecurrenceFrequency.Weekly && interval == 1 && normalizedDays.Count == 7);
+
+        var cadenceSummary = isEveryDay
+            ? $"{Translator.CalendarEventCompose_Every} {Translator.CalendarEventCompose_FrequencyDay}"
+            : interval == 1
+                ? $"{Translator.CalendarEventCompose_Every} {GetSingularFrequencyLabel(frequency)}"
+                : $"{Translator.CalendarEventCompose_Every} {interval.ToString(culture)} {GetPluralFrequencyLabel(frequency)}";
+
+        var weekdaySummary = string.Empty;
+        if (frequency == CalendarItemRecurrenceFrequency.Weekly && normalizedDays.Count > 0 && normalizedDays.Count < 7)
+        {
+            weekdaySummary = string.Format(
+                culture,
+                Translator.CalendarEventCompose_WeekdaySummary,
+                string.Join(", ", normalizedDays.Select(day => culture.DateTimeFormat.GetDayName(day))));
+        }
+
+        var untilSummary = recurrenceEndDate.HasValue
+            ? string.Format(
+                culture,
+                Translator.CalendarEventCompose_UntilSummary,
+                recurrenceEndDate.Value.ToString("ddd yyyy-MM-dd", culture))
+            : string.Empty;
+
+        return string.Format(
+            culture,
+            Translator.CalendarEventCompose_RecurringSummarySmart,
+            cadenceSummary,
+            weekdaySummary,
+            timeSummary,
+            effectiveStart.ToString("dddd yyyy-MM-dd", culture),
+            untilSummary).Trim();
+    }
+
+    private static IReadOnlyList<DayOfWeek> NormalizeDays(IReadOnlyCollection<DayOfWeek> daysOfWeek)
+    {
+        if (daysOfWeek == null || daysOfWeek.Count == 0)
+        {
+            return [];
+        }
+
+        return daysOfWeek
+            .Distinct()
+            .OrderBy(day => Array.IndexOf(OrderedDays, day))
+            .ToList();
+    }
+
+    private static string GetSingularFrequencyLabel(CalendarItemRecurrenceFrequency frequency)
+    {
+        return frequency switch
+        {
+            CalendarItemRecurrenceFrequency.Daily => Translator.CalendarEventCompose_FrequencyDay,
+            CalendarItemRecurrenceFrequency.Weekly => Translator.CalendarEventCompose_FrequencyWeek,
+            CalendarItemRecurrenceFrequency.Monthly => Translator.CalendarEventCompose_FrequencyMonth,
+            CalendarItemRecurrenceFrequency.Yearly => Translator.CalendarEventCompose_FrequencyYear,
+            _ => Translator.CalendarEventCompose_FrequencyWeek
+        };
+    }
+
+    private static string GetPluralFrequencyLabel(CalendarItemRecurrenceFrequency frequency)
+    {
+        return frequency switch
+        {
+            CalendarItemRecurrenceFrequency.Daily => Translator.CalendarEventCompose_FrequencyDayPlural,
+            CalendarItemRecurrenceFrequency.Weekly => Translator.CalendarEventCompose_FrequencyWeekPlural,
+            CalendarItemRecurrenceFrequency.Monthly => Translator.CalendarEventCompose_FrequencyMonthPlural,
+            CalendarItemRecurrenceFrequency.Yearly => Translator.CalendarEventCompose_FrequencyYearPlural,
+            _ => Translator.CalendarEventCompose_FrequencyWeekPlural
+        };
+    }
+}
+
+

Wino.Core.Domain/CalendarReminderSnoozeOptions.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Wino.Core.Domain;
+
+public static class CalendarReminderSnoozeOptions
+{
+    private static readonly int[] SupportedSnoozeMinutes = [5, 10, 15, 30];
+
+    public static IReadOnlyList<int> GetSupportedSnoozeMinutes()
+        => SupportedSnoozeMinutes;
+
+    public static IReadOnlyList<int> GetAllowedSnoozeMinutes(long reminderDurationInSeconds, long defaultReminderDurationInSeconds)
+    {
+        var reminderMinutes = (int)Math.Max(0, reminderDurationInSeconds / 60);
+
+        if (reminderMinutes <= 0)
+            return [];
+
+        var maxSnoozeMinutes = reminderMinutes;
+        var defaultReminderMinutes = (int)Math.Max(0, defaultReminderDurationInSeconds / 60);
+
+        if (defaultReminderMinutes > 0)
+            maxSnoozeMinutes = Math.Min(maxSnoozeMinutes, defaultReminderMinutes);
+
+        return SupportedSnoozeMinutes.Where(minutes => minutes <= maxSnoozeMinutes).ToArray();
+    }
+}

Wino.Core.Domain/Collections/CalendarEventCollection.cs

@@ -0,0 +1,219 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using Itenso.TimePeriod;
+using Wino.Core.Domain.Entities.Calendar;
+using Wino.Core.Domain.Interfaces;
+using Wino.Core.Domain.Models.Calendar;
+
+namespace Wino.Core.Domain.Collections;
+
+public class CalendarEventCollection
+{
+    public event EventHandler<ICalendarItem> CalendarItemAdded;
+    public event EventHandler<ICalendarItem> CalendarItemRemoved;
+    public event EventHandler<ICalendarItem> CalendarItemUpdated;
+
+    public event EventHandler CalendarItemsCleared;
+
+    private ObservableRangeCollection<ICalendarItem> _internalRegularEvents = [];
+    private ObservableRangeCollection<ICalendarItem> _internalAllDayEvents = [];
+
+    public ReadOnlyObservableCollection<ICalendarItem> RegularEvents { get; }
+    public ReadOnlyObservableCollection<ICalendarItem> AllDayEvents { get; } // TODO: Rename this to include multi-day events.
+    public ITimePeriod Period { get; }
+    public CalendarSettings Settings { get; }
+
+    private readonly List<ICalendarItem> _allItems = new List<ICalendarItem>();
+
+    public CalendarEventCollection(ITimePeriod period, CalendarSettings settings)
+    {
+        Period = period;
+        Settings = settings;
+
+        RegularEvents = new ReadOnlyObservableCollection<ICalendarItem>(_internalRegularEvents);
+        AllDayEvents = new ReadOnlyObservableCollection<ICalendarItem>(_internalAllDayEvents);
+    }
+
+    public bool HasCalendarEvent(AccountCalendar accountCalendar)
+        => _allItems.Any(x => x.AssignedCalendar.Id == accountCalendar.Id);
+
+    public ICalendarItem GetCalendarItem(Guid calendarItemId)
+    {
+        return _allItems.FirstOrDefault(x => x.Id == calendarItemId);
+    }
+
+    public void ClearSelectionStates()
+    {
+        foreach (var item in _allItems)
+        {
+            if (item is ICalendarItemViewModel calendarItemViewModel)
+            {
+                calendarItemViewModel.IsSelected = false;
+            }
+        }
+    }
+
+    public void FilterByCalendars(IEnumerable<Guid> visibleCalendarIds)
+    {
+        foreach (var item in _allItems)
+        {
+            var collections = GetProperCollectionsForCalendarItem(item);
+
+            foreach (var collection in collections)
+            {
+                if (!visibleCalendarIds.Contains(item.AssignedCalendar.Id) && collection.Contains(item))
+                {
+                    RemoveCalendarItemInternal(collection, item, false);
+                }
+                else if (visibleCalendarIds.Contains(item.AssignedCalendar.Id) && !collection.Contains(item))
+                {
+                    AddCalendarItemInternal(collection, item, false);
+                }
+            }
+        }
+    }
+
+    private IEnumerable<ObservableRangeCollection<ICalendarItem>> GetProperCollectionsForCalendarItem(ICalendarItem calendarItem)
+    {
+        // All-day events go to all days.
+        // Multi-day events go to both.
+        // Anything else goes to regular.
+
+        if (calendarItem.IsAllDayEvent)
+        {
+            return [_internalAllDayEvents];
+        }
+        else if (calendarItem.IsMultiDayEvent)
+        {
+            return [_internalRegularEvents, _internalAllDayEvents];
+        }
+        else
+        {
+            return [_internalRegularEvents];
+        }
+    }
+
+    public void AddCalendarItem(ICalendarItem calendarItem)
+    {
+        var collections = GetProperCollectionsForCalendarItem(calendarItem);
+
+        foreach (var collection in collections)
+        {
+            AddCalendarItemInternal(collection, calendarItem);
+        }
+    }
+
+    public void RemoveCalendarItem(ICalendarItem calendarItem)
+    {
+        var collections = GetProperCollectionsForCalendarItem(calendarItem);
+
+        foreach (var collection in collections)
+        {
+            RemoveCalendarItemInternal(collection, calendarItem);
+        }
+    }
+
+    public void RemoveCalendarItems(Func<ICalendarItem, bool> predicate)
+    {
+        if (predicate == null) return;
+
+        var itemsToRemove = _allItems.Where(predicate).ToList();
+
+        foreach (var item in itemsToRemove)
+        {
+            RemoveCalendarItem(item);
+        }
+    }
+
+    private void AddCalendarItemInternal(ObservableRangeCollection<ICalendarItem> collection, ICalendarItem calendarItem, bool create = true)
+    {
+        if (calendarItem is not ICalendarItemViewModel viewModel)
+            throw new ArgumentException("CalendarItem must be of type ICalendarItemViewModel", nameof(calendarItem));
+
+        // Set the displaying context for proper title calculation
+        viewModel.DisplayingPeriod = Period;
+        viewModel.CalendarSettings = Settings;
+
+        collection.Add(calendarItem);
+
+        if (create)
+        {
+            _allItems.Add(calendarItem);
+        }
+
+        CalendarItemAdded?.Invoke(this, calendarItem);
+    }
+
+    private void RemoveCalendarItemInternal(ObservableRangeCollection<ICalendarItem> collection, ICalendarItem calendarItem, bool destroy = true)
+    {
+        if (calendarItem is not ICalendarItemViewModel)
+            throw new ArgumentException("CalendarItem must be of type ICalendarItemViewModel", nameof(calendarItem));
+
+        collection.Remove(calendarItem);
+
+        if (destroy)
+        {
+            _allItems.Remove(calendarItem);
+        }
+
+        CalendarItemRemoved?.Invoke(this, calendarItem);
+    }
+
+    /// <summary>
+    /// Updates an existing calendar item in-place. If the item's type changed (all-day vs regular),
+    /// it will be moved to the appropriate collection.
+    /// </summary>
+    /// <param name="calendarItem">The updated calendar item data.</param>
+    /// <returns>True if the item was found and updated; false otherwise.</returns>
+    public bool UpdateCalendarItem(CalendarItem calendarItem)
+    {
+        var existingItem = _allItems.FirstOrDefault(x => x.Id == calendarItem.Id);
+        if (existingItem == null)
+            return false;
+
+        // Get the collections this item is currently in (before update)
+        var oldCollections = GetProperCollectionsForCalendarItem(existingItem).ToList();
+
+        // Update the underlying data
+        if (existingItem is ICalendarItemViewModel viewModel)
+        {
+            viewModel.UpdateFrom(calendarItem);
+        }
+
+        // Get the collections this item should be in (after update)
+        var newCollections = GetProperCollectionsForCalendarItem(existingItem).ToList();
+
+        // Check if the collections changed
+        var collectionsToRemoveFrom = oldCollections.Except(newCollections).ToList();
+        var collectionsToAddTo = newCollections.Except(oldCollections).ToList();
+
+        // Remove from old collections that are no longer applicable
+        foreach (var collection in collectionsToRemoveFrom)
+        {
+            collection.Remove(existingItem);
+        }
+
+        // Add to new collections that are now applicable
+        foreach (var collection in collectionsToAddTo)
+        {
+            if (!collection.Contains(existingItem))
+            {
+                collection.Add(existingItem);
+            }
+        }
+
+        CalendarItemUpdated?.Invoke(this, existingItem);
+        return true;
+    }
+
+    public void Clear()
+    {
+        _internalAllDayEvents.Clear();
+        _internalRegularEvents.Clear();
+        _allItems.Clear();
+
+        CalendarItemsCleared?.Invoke(this, EventArgs.Empty);
+    }
+}

Wino.Core.Domain/Collections/ObservableRangeCollection.cs

@@ -0,0 +1,173 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.ComponentModel;
+
+namespace Wino.Core.Domain.Collections;
+
+/// <summary> 
+/// Represents a dynamic data collection that provides notifications when items get added, removed, or when the whole list is refreshed. 
+/// </summary> 
+/// <typeparam name="T"></typeparam> 
+public class ObservableRangeCollection<T> : ObservableCollection<T>
+{
+
+    /// <summary> 
+    /// Initializes a new instance of the System.Collections.ObjectModel.ObservableCollection(Of T) class. 
+    /// </summary> 
+    public ObservableRangeCollection()
+        : base()
+    {
+    }
+
+    /// <summary> 
+    /// Initializes a new instance of the System.Collections.ObjectModel.ObservableCollection(Of T) class that contains elements copied from the specified collection. 
+    /// </summary> 
+    /// <param name="collection">collection: The collection from which the elements are copied.</param> 
+    /// <exception cref="ArgumentNullException">The collection parameter cannot be null.</exception> 
+    public ObservableRangeCollection(IEnumerable<T> collection)
+        : base(collection)
+    {
+    }
+
+    /// <summary> 
+    /// Adds the elements of the specified collection to the end of the ObservableCollection(Of T). 
+    /// </summary> 
+    public void AddRange(IEnumerable<T> collection, NotifyCollectionChangedAction notificationMode = NotifyCollectionChangedAction.Add)
+    {
+        if (notificationMode != NotifyCollectionChangedAction.Add && notificationMode != NotifyCollectionChangedAction.Reset)
+            throw new ArgumentException("Mode must be either Add or Reset for AddRange.", nameof(notificationMode));
+        if (collection == null)
+            throw new ArgumentNullException(nameof(collection));
+
+        CheckReentrancy();
+
+        var startIndex = Count;
+
+        var itemsAdded = AddArrangeCore(collection);
+
+        if (!itemsAdded)
+            return;
+
+        if (notificationMode == NotifyCollectionChangedAction.Reset)
+        {
+            RaiseChangeNotificationEvents(action: NotifyCollectionChangedAction.Reset);
+
+            return;
+        }
+
+        var changedItems = collection is List<T> ? (List<T>)collection : new List<T>(collection);
+
+        RaiseChangeNotificationEvents(
+            action: NotifyCollectionChangedAction.Add,
+            changedItems: changedItems,
+            startingIndex: startIndex);
+    }
+
+    /// <summary> 
+    /// Removes the first occurence of each item in the specified collection from ObservableCollection(Of T). NOTE: with notificationMode = Remove, removed items starting index is not set because items are not guaranteed to be consecutive.
+    /// </summary> 
+    public void RemoveRange(IEnumerable<T> collection, NotifyCollectionChangedAction notificationMode = NotifyCollectionChangedAction.Reset)
+    {
+        if (notificationMode != NotifyCollectionChangedAction.Remove && notificationMode != NotifyCollectionChangedAction.Reset)
+            throw new ArgumentException("Mode must be either Remove or Reset for RemoveRange.", nameof(notificationMode));
+        if (collection == null)
+            throw new ArgumentNullException(nameof(collection));
+
+        CheckReentrancy();
+
+        if (notificationMode == NotifyCollectionChangedAction.Reset)
+        {
+            var raiseEvents = false;
+            foreach (var item in collection)
+            {
+                Items.Remove(item);
+                raiseEvents = true;
+            }
+
+            if (raiseEvents)
+                RaiseChangeNotificationEvents(action: NotifyCollectionChangedAction.Reset);
+
+            return;
+        }
+
+        var changedItems = new List<T>(collection);
+        for (var i = 0; i < changedItems.Count; i++)
+        {
+            if (!Items.Remove(changedItems[i]))
+            {
+                changedItems.RemoveAt(i); //Can't use a foreach because changedItems is intended to be (carefully) modified
+                i--;
+            }
+        }
+
+        if (changedItems.Count == 0)
+            return;
+
+        RaiseChangeNotificationEvents(
+            action: NotifyCollectionChangedAction.Remove,
+            changedItems: changedItems);
+    }
+
+    /// <summary> 
+    /// Clears the current collection and replaces it with the specified item. 
+    /// </summary> 
+    public void Replace(T item) => ReplaceRange(new T[] { item });
+
+    /// <summary> 
+    /// Clears the current collection and replaces it with the specified collection. 
+    /// </summary> 
+    public void ReplaceRange(IEnumerable<T> collection)
+    {
+        if (collection == null)
+            throw new ArgumentNullException(nameof(collection));
+
+        CheckReentrancy();
+
+        var previouslyEmpty = Items.Count == 0;
+
+        Items.Clear();
+
+        AddArrangeCore(collection);
+
+        var currentlyEmpty = Items.Count == 0;
+
+        if (previouslyEmpty && currentlyEmpty)
+            return;
+
+        RaiseChangeNotificationEvents(action: NotifyCollectionChangedAction.Reset);
+    }
+
+    public void InsertRange(IEnumerable<T> items)
+    {
+        CheckReentrancy();
+
+        foreach (var item in items)
+            Items.Insert(0, item);
+
+        OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
+    }
+
+    private bool AddArrangeCore(IEnumerable<T> collection)
+    {
+        var itemAdded = false;
+        foreach (var item in collection)
+        {
+            Items.Add(item);
+            itemAdded = true;
+        }
+        return itemAdded;
+    }
+
+    private void RaiseChangeNotificationEvents(NotifyCollectionChangedAction action, List<T> changedItems = null, int startingIndex = -1)
+    {
+        OnPropertyChanged(new PropertyChangedEventArgs(nameof(Count)));
+        OnPropertyChanged(new PropertyChangedEventArgs("Item[]"));
+
+        if (changedItems is null)
+            OnCollectionChanged(new NotifyCollectionChangedEventArgs(action));
+        else
+            OnCollectionChanged(new NotifyCollectionChangedEventArgs(action, changedItems: changedItems, startingIndex: startingIndex));
+    }
+}

Wino.Core.Domain/Constants.cs

@@ -1,17 +1,37 @@
-namespace Wino.Core.Domain
+namespace Wino.Core.Domain;
+
+public static class Constants
 {
-    public static class Constants
-    {
-        /// <summary>
-        /// MIME header that exists in all the drafts created from Wino.
-        /// </summary>
-        public const string WinoLocalDraftHeader = "X-Wino-Draft-Id";
-        public const string LocalDraftStartPrefix = "localDraft_";
+    /// <summary>
+    /// MIME header that exists in all the drafts created from Wino.
+    /// </summary>
+    public const string WinoLocalDraftHeader = "X-Wino-Draft-Id";
+    public const string DispositionNotificationToHeader = "Disposition-Notification-To";
+    public const string OriginalMessageIdHeader = "Original-Message-ID";
+    public const string LocalDraftStartPrefix = "localDraft_";
 
-        public const string ToastMailUniqueIdKey = nameof(ToastMailUniqueIdKey);
-        public const string ToastActionKey = nameof(ToastActionKey);
+    public const string CalendarEventRecurrenceRuleSeperator = "___";
 
-        public const string ClientLogFile = "Client_.log";
-        public const string ServerLogFile = "Server_.log";
-    }
+    public const string ToastMailUniqueIdKey = nameof(ToastMailUniqueIdKey);
+    public const string ToastActionKey = nameof(ToastActionKey);
+    public const string ToastMailAccountIdKey = nameof(ToastMailAccountIdKey);
+    public const string ToastCalendarItemIdKey = nameof(ToastCalendarItemIdKey);
+    public const string ToastCalendarActionKey = nameof(ToastCalendarActionKey);
+    public const string ToastCalendarNavigateAction = nameof(ToastCalendarNavigateAction);
+    public const string ToastCalendarJoinOnlineAction = nameof(ToastCalendarJoinOnlineAction);
+    public const string ToastCalendarSnoozeAction = nameof(ToastCalendarSnoozeAction);
+    public const string ToastCalendarSnoozeDurationInputId = nameof(ToastCalendarSnoozeDurationInputId);
+    public const string ToastModeKey = nameof(ToastModeKey);
+    public const string ToastModeMail = nameof(ToastModeMail);
+    public const string ToastModeCalendar = nameof(ToastModeCalendar);
+    public const string ToastDismissActionKey = nameof(ToastDismissActionKey);
+    public const string ToastStoreUpdateActionKey = nameof(ToastStoreUpdateActionKey);
+    public const string ToastStoreUpdateActionInstall = nameof(ToastStoreUpdateActionInstall);
+    public const string ClientLogFile = "Client_.log";
+    public const string ServerLogFile = "Server_.log";
+    public const string LogArchiveFileName = "WinoLogs.zip";
+
+    public const string WinoMailIdentiifer = nameof(WinoMailIdentiifer);
+    public const string WinoCalendarIdentifier = nameof(WinoCalendarIdentifier);
 }
+

Wino.Core.Domain/Entities/AccountSignature.cs

@@ -1,17 +0,0 @@
-using System;
-using SQLite;
-
-namespace Wino.Core.Domain.Entities
-{
-    public class AccountSignature
-    {
-        [PrimaryKey]
-        public Guid Id { get; set; }
-
-        public string Name { get; set; }
-
-        public string HtmlBody { get; set; }
-
-        public Guid MailAccountId { get; set; }
-    }
-}

Wino.Core.Domain/Entities/AddressInformation.cs

@@ -1,53 +0,0 @@
-using SQLite;
-using System;
-using System.Collections.Generic;
-
-namespace Wino.Core.Domain.Entities
-{
-    /// <summary>
-    /// Back storage for simple name-address book.
-    /// These values will be inserted during MIME fetch.
-    /// </summary>
-
-
-    // TODO: This can easily evolve to Contact store, just like People app in Windows 10/11.
-    // Do it.
-    public class AddressInformation : IEquatable<AddressInformation>
-    {
-        [PrimaryKey]
-        public string Address { get; set; }
-        public string Name { get; set; }
-
-        public string DisplayName => Address == Name ? Address : $"{Name} <{Address}>";
-
-        public override bool Equals(object obj)
-        {
-            return Equals(obj as AddressInformation);
-        }
-
-        public bool Equals(AddressInformation other)
-        {
-            return !(other is null) &&
-                   Address == other.Address &&
-                   Name == other.Name;
-        }
-
-        public override int GetHashCode()
-        {
-            int hashCode = -1717786383;
-            hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(Address);
-            hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(Name);
-            return hashCode;
-        }
-
-        public static bool operator ==(AddressInformation left, AddressInformation right)
-        {
-            return EqualityComparer<AddressInformation>.Default.Equals(left, right);
-        }
-
-        public static bool operator !=(AddressInformation left, AddressInformation right)
-        {
-            return !(left == right);
-        }
-    }
-}

Wino.Core.Domain/Entities/Calendar/AccountCalendar.cs

@@ -0,0 +1,34 @@
+using System;
+using SQLite;
+using Wino.Core.Domain.Entities.Shared;
+using Wino.Core.Domain.Enums;
+using Wino.Core.Domain.Interfaces;
+
+namespace Wino.Core.Domain.Entities.Calendar;
+
+[Preserve]
+public class AccountCalendar : IAccountCalendar
+{
+    [PrimaryKey]
+    public Guid Id { get; set; }
+    public Guid AccountId { get; set; }
+    public string RemoteCalendarId { get; set; }
+    public string SynchronizationDeltaToken { get; set; }
+    public string Name { get; set; }
+    public bool IsPrimary { get; set; }
+    public bool IsReadOnly { get; set; }
+    public bool IsSynchronizationEnabled { get; set; } = true;
+    public bool IsExtended { get; set; } = true;
+    public CalendarItemShowAs DefaultShowAs { get; set; } = CalendarItemShowAs.Busy;
+
+    /// <summary>
+    /// Unused for now.
+    /// </summary>
+    public string TextColorHex { get; set; }
+    public string BackgroundColorHex { get; set; }
+    public bool IsBackgroundColorUserOverridden { get; set; }
+    public string TimeZone { get; set; }
+
+    [Ignore]
+    public MailAccount MailAccount { get; set; }
+}

Wino.Core.Domain/Entities/Calendar/CalendarAttachment.cs

@@ -0,0 +1,55 @@
+using System;
+using SQLite;
+using Wino.Core.Domain.Enums;
+
+namespace Wino.Core.Domain.Entities.Calendar;
+
+/// <summary>
+/// Represents metadata for calendar event attachments.
+/// Actual file content is downloaded on-demand.
+/// </summary>
+public class CalendarAttachment
+{
+    [PrimaryKey]
+    public Guid Id { get; set; }
+
+    /// <summary>
+    /// The calendar item this attachment belongs to.
+    /// </summary>
+    public Guid CalendarItemId { get; set; }
+
+    /// <summary>
+    /// Remote identifier for the attachment from the provider (Outlook, Gmail, etc.).
+    /// </summary>
+    public string RemoteAttachmentId { get; set; }
+
+    /// <summary>
+    /// File name of the attachment.
+    /// </summary>
+    public string FileName { get; set; }
+
+    /// <summary>
+    /// Size of the attachment in bytes.
+    /// </summary>
+    public long Size { get; set; }
+
+    /// <summary>
+    /// MIME content type (e.g., "application/pdf", "image/png").
+    /// </summary>
+    public string ContentType { get; set; }
+
+    /// <summary>
+    /// Whether the attachment has been downloaded to local storage.
+    /// </summary>
+    public bool IsDownloaded { get; set; }
+
+    /// <summary>
+    /// Local file path where the attachment is stored (if downloaded).
+    /// </summary>
+    public string LocalFilePath { get; set; }
+
+    /// <summary>
+    /// When the attachment was last modified.
+    /// </summary>
+    public DateTimeOffset LastModified { get; set; }
+}

Wino.Core.Domain/Entities/Calendar/CalendarEventAttendee.cs

@@ -0,0 +1,26 @@
+using System;
+using SQLite;
+using Wino.Core.Domain.Entities.Shared;
+using Wino.Core.Domain.Enums;
+
+namespace Wino.Core.Domain.Entities.Calendar;
+
+public class CalendarEventAttendee
+{
+    [PrimaryKey]
+    public Guid Id { get; set; }
+    public Guid CalendarItemId { get; set; }
+    public string Name { get; set; }
+    public string Email { get; set; }
+    public AttendeeStatus AttendenceStatus { get; set; }
+    public bool IsOrganizer { get; set; }
+    public bool IsOptionalAttendee { get; set; }
+    public string Comment { get; set; }
+
+    /// <summary>
+    /// Resolved contact from the contact store. Populated at runtime via IContactService;
+    /// not persisted to the database.
+    /// </summary>
+    [Ignore]
+    public AccountContact ResolvedContact { get; set; }
+}

Wino.Core.Domain/Entities/Calendar/CalendarItem.cs

@@ -0,0 +1,209 @@
+using System;
+using System.Diagnostics;
+using Itenso.TimePeriod;
+using SQLite;
+using Wino.Core.Domain.Enums;
+using Wino.Core.Domain.Extensions;
+using Wino.Core.Domain.Interfaces;
+using Wino.Core.Domain.Models.Calendar;
+
+namespace Wino.Core.Domain.Entities.Calendar;
+
+[DebuggerDisplay("{Title} ({StartDate} - {EndDate})")]
+public class CalendarItem : ICalendarItem
+{
+    [PrimaryKey]
+    public Guid Id { get; set; }
+    public string RemoteEventId { get; set; }
+    public string Title { get; set; }
+    public string Description { get; set; }
+    public string Location { get; set; }
+
+    /// <summary>
+    /// Indicates whether this item is a local preview that hasn't been synced to the server yet.
+    /// When true, the item exists only in the local database without a RemoteEventId.
+    /// Used to prevent duplicates when the server returns the newly created event.
+    /// </summary>
+    [Ignore]
+    public bool IsLocalPreview => string.IsNullOrEmpty(RemoteEventId);
+
+    public DateTime StartDate { get; set; }
+
+    public DateTime EndDate
+    {
+        get
+        {
+            return StartDate.AddSeconds(DurationInSeconds);
+        }
+    }
+
+    /// <summary>
+    /// IANA timezone identifier for the start time (e.g., "America/New_York", "Europe/London").
+    /// If null or empty, UTC is assumed.
+    /// </summary>
+    public string StartTimeZone { get; set; }
+
+    /// <summary>
+    /// IANA timezone identifier for the end time (e.g., "America/New_York", "Europe/London").
+    /// If null or empty, UTC is assumed.
+    /// </summary>
+    public string EndTimeZone { get; set; }
+
+    private ITimePeriod _period;
+    public ITimePeriod Period
+    {
+        get
+        {
+            _period ??= new TimeRange(StartDate, EndDate);
+
+            return _period;
+        }
+    }
+
+    /// <summary>
+    /// Events that starts at midnight and ends at midnight are considered all-day events.
+    /// </summary>
+    public bool IsAllDayEvent
+    {
+        get
+        {
+            return
+                StartDate.TimeOfDay == TimeSpan.Zero &&
+                EndDate.TimeOfDay == TimeSpan.Zero;
+        }
+    }
+
+    /// <summary>
+    /// Events that are child instances of a recurring event (occurrences or exceptions).
+    /// </summary>
+    public bool IsRecurringChild
+    {
+        get
+        {
+            return RecurringCalendarItemId != null;
+        }
+    }
+
+    /// <summary>
+    /// Events that are part of a recurring series (either as parent or child).
+    /// </summary>
+    public bool IsRecurringEvent => IsRecurringChild || IsRecurringParent;
+
+    /// <summary>
+    /// Events that are the master event definition of recurrence events.
+    /// </summary>
+    public bool IsRecurringParent
+    {
+        get
+        {
+            return !string.IsNullOrEmpty(Recurrence) && RecurringCalendarItemId == null;
+        }
+    }
+
+    /// <summary>
+    /// Events that are not all-day events and last more than one day are considered multi-day events.
+    /// </summary>
+    public bool IsMultiDayEvent
+    {
+        get
+        {
+            return Period.Duration.TotalDays >= 1 && !IsAllDayEvent;
+        }
+    }
+
+    public double DurationInSeconds { get; set; }
+    public string Recurrence { get; set; }
+
+    public string OrganizerDisplayName { get; set; }
+    public string OrganizerEmail { get; set; }
+
+    /// <summary>
+    /// The id of the parent calendar item of the recurring event.
+    /// Exceptional instances are stored as a separate calendar item.
+    /// This makes the calendar item a child of the recurring event.
+    /// </summary>
+    public Guid? RecurringCalendarItemId { get; set; }
+
+    /// <summary>
+    /// Indicates read-only events. Default is false.
+    /// </summary>
+    public bool IsLocked { get; set; }
+
+    /// <summary>
+    /// Hidden events must not be displayed to the user.
+    /// This usually happens when a child instance of recurring parent is cancelled after creation.
+    /// </summary>
+    public bool IsHidden { get; set; }
+
+    // TODO
+    public string CustomEventColorHex { get; set; }
+    public string HtmlLink { get; set; }
+    public DateTime? SnoozedUntil { get; set; }
+    public CalendarItemStatus Status { get; set; }
+    public CalendarItemVisibility Visibility { get; set; }
+
+    /// <summary>
+    /// Indicates how the event should be shown in the calendar (Free, Busy, Tentative, etc.).
+    /// </summary>
+    public CalendarItemShowAs ShowAs { get; set; } = CalendarItemShowAs.Busy;
+
+    public DateTimeOffset CreatedAt { get; set; }
+    public DateTimeOffset UpdatedAt { get; set; }
+    public Guid CalendarId { get; set; }
+
+    [Ignore]
+    public IAccountCalendar AssignedCalendar { get; set; }
+
+    [Ignore]
+    public bool CanChangeStartAndEndDate
+    {
+        get
+        {
+            if (IsLocked)
+            {
+                return false;
+            }
+
+            var accountAddress = AssignedCalendar?.MailAccount?.Address;
+
+            return string.IsNullOrWhiteSpace(OrganizerEmail) ||
+                   string.IsNullOrWhiteSpace(accountAddress) ||
+                   string.Equals(OrganizerEmail, accountAddress, StringComparison.OrdinalIgnoreCase);
+        }
+    }
+
+    /// <summary>
+    /// Id to load information related to this event (attendees, reminders, etc.).
+    /// For child events, if they have their own data, use their own Id.
+    /// For events that share data with their parent, return parent's Id.
+    /// </summary>
+    public Guid EventTrackingId => Id;
+
+    /// <summary>
+    /// Gets the start date converted to user's local timezone for display.
+    /// StartDate is stored according to StartTimeZone.
+    /// </summary>
+    [Ignore]
+    public DateTime LocalStartDate
+    {
+        get
+        {
+            return this.GetLocalStartDate();
+        }
+    }
+
+    /// <summary>
+    /// Gets the end date converted to user's local timezone for display.
+    /// EndDate is calculated from StartDate and is in StartTimeZone.
+    /// </summary>
+    [Ignore]
+    public DateTime LocalEndDate
+    {
+        get
+        {
+            return this.GetLocalEndDate();
+        }
+    }
+
+    public string GetDisplayTitle(ITimePeriod displayingPeriod, CalendarSettings calendarSettings) => Period.ToString();
+}

Wino.Core.Domain/Entities/Calendar/Reminder.cs

@@ -0,0 +1,19 @@
+using System;
+using SQLite;
+using Wino.Core.Domain.Enums;
+
+namespace Wino.Core.Domain.Entities.Calendar;
+
+public class Reminder
+{
+    [PrimaryKey]
+    public Guid Id { get; set; }
+    public Guid CalendarItemId { get; set; }
+
+    /// <summary>
+    /// Duration in seconds before the event start time when the reminder should trigger.
+    /// For example, 900 seconds = 15 minutes before event.
+    /// </summary>
+    public long DurationInSeconds { get; set; }
+    public CalendarItemReminderType ReminderType { get; set; }
+}

Wino.Core.Domain/Entities/CustomServerInformation.cs

@@ -1,53 +0,0 @@
-using System;
-using SQLite;
-using Wino.Core.Domain.Enums;
-
-namespace Wino.Core.Domain.Entities
-{
-    public class CustomServerInformation
-    {
-        [PrimaryKey]
-        public Guid Id { get; set; }
-
-        public Guid AccountId { get; set; }
-
-        /// <summary>
-        /// This field is ignored. DisplayName is stored in MailAccount as SenderName from now.
-        /// </summary>
-        [Ignore]
-        public string DisplayName { get; set; }
-        public string Address { get; set; }
-        public string IncomingServer { get; set; }
-        public string IncomingServerUsername { get; set; }
-        public string IncomingServerPassword { get; set; }
-        public string IncomingServerPort { get; set; }
-
-        public CustomIncomingServerType IncomingServerType { get; set; }
-
-        public string OutgoingServer { get; set; }
-        public string OutgoingServerPort { get; set; }
-        public string OutgoingServerUsername { get; set; }
-        public string OutgoingServerPassword { get; set; }
-
-        /// <summary>
-        /// useSSL True: SslOnConnect
-        /// useSSL False: StartTlsWhenAvailable
-        /// </summary>
-
-        public ImapConnectionSecurity IncomingServerSocketOption { get; set; }
-        public ImapAuthenticationMethod IncomingAuthenticationMethod { get; set; }
-
-
-        public ImapConnectionSecurity OutgoingServerSocketOption { get; set; }
-        public ImapAuthenticationMethod OutgoingAuthenticationMethod { get; set; }
-
-        public string ProxyServer { get; set; }
-        public string ProxyServerPort { get; set; }
-
-        /// <summary>
-        /// Number of concurrent clients that can connect to the server.
-        /// Default is 5.
-        /// </summary>
-        public int MaxConcurrentClients { get; set; }
-    }
-}

Wino.Core.Domain/Entities/Mail/AccountSignature.cs

@@ -0,0 +1,16 @@
+using System;
+using SQLite;
+
+namespace Wino.Core.Domain.Entities.Mail;
+
+public class AccountSignature
+{
+    [PrimaryKey]
+    public Guid Id { get; set; }
+
+    public string Name { get; set; }
+
+    public string HtmlBody { get; set; }
+
+    public Guid MailAccountId { get; set; }
+}

Wino.Core.Domain/Entities/Mail/EmailTemplate.cs

@@ -0,0 +1,16 @@
+using System;
+using SQLite;
+
+namespace Wino.Core.Domain.Entities.Mail;
+
+public class EmailTemplate
+{
+    [PrimaryKey]
+    public Guid Id { get; set; }
+
+    public string Name { get; set; } = string.Empty;
+
+    public string Description { get; set; } = string.Empty;
+
+    public string HtmlContent { get; set; } = string.Empty;
+}

Wino.Core.Domain/Entities/Mail/MailAccountAlias.cs

@@ -0,0 +1,109 @@
+using System;
+using System.Collections.ObjectModel;
+using System.Security.Cryptography.X509Certificates;
+using SQLite;
+using Wino.Core.Domain;
+using Wino.Core.Domain.Enums;
+
+namespace Wino.Core.Domain.Entities.Mail;
+
+public class RemoteAccountAlias
+{
+    /// <summary>
+    /// Display address of the alias.
+    /// </summary>
+    public string AliasAddress { get; set; }
+
+    /// <summary>
+    /// Address to be included in Reply-To header when alias is used for sending messages.
+    /// </summary>
+    public string ReplyToAddress { get; set; }
+
+    /// <summary>
+    /// Whether this alias is the primary alias for the account.
+    /// </summary>
+    public bool IsPrimary { get; set; }
+
+    /// <summary>
+    /// Whether the alias is verified by the server.
+    /// Only Gmail aliases are verified for now.
+    /// Non-verified alias messages might be rejected by SMTP server.
+    /// </summary>
+    public bool IsVerified { get; set; }
+
+    /// <summary>
+    /// Whether this alias is the root alias for the account.
+    /// Root alias means the first alias that was created for the account.
+    /// It can't be deleted or changed.
+    /// </summary>
+    public bool IsRootAlias { get; set; }
+
+    /// <summary>
+    /// Optional sender name for the alias.
+    /// Falls back to account's sender name if not set when preparing messages.
+    /// Used for Gmail only.
+    /// </summary>
+    public string AliasSenderName { get; set; }
+
+    /// <summary>
+    /// Whether the alias was entered by the user or discovered from the provider.
+    /// </summary>
+    public AliasSource Source { get; set; } = AliasSource.Manual;
+
+    /// <summary>
+    /// Represents Wino's confidence that the alias can be used for sending.
+    /// </summary>
+    public AliasSendCapability SendCapability { get; set; } = AliasSendCapability.Unknown;
+}
+
+public class MailAccountAlias : RemoteAccountAlias
+{
+    /// <summary>
+    /// Unique Id for the alias.
+    /// </summary>
+    [PrimaryKey]
+    public Guid Id { get; set; }
+
+    /// <summary>
+    /// Account id that this alias is attached to.
+    /// </summary>
+    public Guid AccountId { get; set; }
+
+    /// <summary>
+    /// Root aliases can't be deleted.
+    /// </summary>
+    public bool CanDelete => !IsRootAlias;
+
+    public string SelectedSigningCertificateThumbprint { get; set; }
+    public bool IsSmimeEncryptionEnabled { get; set; }
+
+    [Ignore]
+    public X509Certificate2 SelectedSigningCertificate { get; set; }
+
+    [Ignore]
+    public ObservableCollection<X509Certificate2> Certificates { get; set; } = [];
+
+    [Ignore]
+    public bool IsCapabilityConfirmed => SendCapability == AliasSendCapability.Confirmed;
+
+    [Ignore]
+    public bool IsCapabilityUnknown => SendCapability == AliasSendCapability.Unknown;
+
+    [Ignore]
+    public bool IsCapabilityDenied => SendCapability == AliasSendCapability.Denied;
+
+    [Ignore]
+    public string CapabilityDisplayName => SendCapability switch
+    {
+        AliasSendCapability.Confirmed => Translator.AccountAlias_Status_Confirmed,
+        AliasSendCapability.Denied => Translator.AccountAlias_Status_Denied,
+        _ => Translator.AccountAlias_Status_Unknown
+    };
+
+    [Ignore]
+    public string SourceDisplayName => Source switch
+    {
+        AliasSource.ProviderDiscovered => Translator.AccountAlias_Source_ProviderDiscovered,
+        _ => Translator.AccountAlias_Source_Manual
+    };
+}

Wino.Core.Domain/Entities/Mail/MailCategory.cs

@@ -0,0 +1,25 @@
+using System;
+using SQLite;
+using Wino.Core.Domain.Enums;
+
+namespace Wino.Core.Domain.Entities.Mail;
+
+public class MailCategory
+{
+    [PrimaryKey]
+    public Guid Id { get; set; }
+
+    public Guid MailAccountId { get; set; }
+
+    public string RemoteId { get; set; }
+
+    public string Name { get; set; }
+
+    public bool IsFavorite { get; set; }
+
+    public string BackgroundColorHex { get; set; }
+
+    public string TextColorHex { get; set; }
+
+    public MailCategorySource Source { get; set; } = MailCategorySource.Local;
+}

Wino.Core.Domain/Entities/Mail/MailCategoryAssignment.cs

@@ -0,0 +1,14 @@
+using System;
+using SQLite;
+
+namespace Wino.Core.Domain.Entities.Mail;
+
+public class MailCategoryAssignment
+{
+    [PrimaryKey]
+    public Guid Id { get; set; }
+
+    public Guid MailCategoryId { get; set; }
+
+    public Guid MailCopyUniqueId { get; set; }
+}

Wino.Core.Domain/Entities/Mail/MailCopy.cs

@@ -0,0 +1,172 @@
+using System;
+using System.Collections.Generic;
+using SQLite;
+using Wino.Core.Domain.Entities.Shared;
+using Wino.Core.Domain.Enums;
+
+namespace Wino.Core.Domain.Entities.Mail;
+
+/// <summary>
+/// Summary of the parsed MIME messages.
+/// Wino will do non-network operations on this table and others from the original MIME.
+/// </summary>
+public class MailCopy
+{
+    /// <summary>
+    /// Unique Id of the mail.
+    /// </summary>
+    [PrimaryKey]
+    public Guid UniqueId { get; set; }
+
+    /// <summary>
+    /// Not unique id of the item. Some operations held on this Id, some on the UniqueId.
+    /// Same message can be in different folder. In that case UniqueId is used.
+    /// </summary>
+    public string Id { get; set; }
+
+    /// <summary>
+    /// Folder that this mail belongs to.
+    /// </summary>
+    public Guid FolderId { get; set; }
+
+    /// <summary>
+    /// Conversation id for the mail.
+    /// </summary>
+    public string ThreadId { get; set; }
+
+    /// <summary>
+    /// MIME MessageId if exists.
+    /// </summary>
+    public string MessageId { get; set; }
+
+    /// <summary>
+    /// References header from MIME
+    /// </summary>
+    public string References { get; set; }
+
+    /// <summary>
+    /// In-Reply-To header from MIME
+    /// </summary>
+    public string InReplyTo { get; set; }
+
+    /// <summary>
+    /// Name for the sender.
+    /// </summary>
+    public string FromName { get; set; }
+
+    /// <summary>
+    /// Address of the sender.
+    /// </summary>
+    public string FromAddress { get; set; }
+
+    /// <summary>
+    /// Subject of the mail.
+    /// </summary>
+    public string Subject { get; set; }
+
+    /// <summary>
+    /// Short preview of the content.
+    /// </summary>
+    public string PreviewText { get; set; }
+
+    /// <summary>
+    /// Date that represents this mail has been created in provider servers.
+    /// Stored always in UTC.
+    /// </summary>
+    public DateTime CreationDate { get; set; }
+
+    /// <summary>
+    /// Importance of the mail.
+    /// </summary>
+    public MailImportance Importance { get; set; }
+
+    /// <summary>
+    /// Read status for the mail.
+    /// </summary>
+    public bool IsRead { get; set; }
+
+    /// <summary>
+    /// Flag status.
+    /// Flagged for Outlook.
+    /// Important for Gmail.
+    /// </summary>
+    public bool IsFlagged { get; set; }
+
+    /// <summary>
+    /// To support Outlook.
+    /// Gmail doesn't use it.
+    /// </summary>
+    public bool IsFocused { get; set; }
+
+    /// <summary>
+    /// Whether mail has attachments included or not.
+    /// </summary>
+    public bool HasAttachments { get; set; }
+
+    /// <summary>
+    /// Type of mail item (regular mail, calendar invitation, calendar response, etc.).
+    /// </summary>
+    public MailItemType ItemType { get; set; } = MailItemType.Mail;
+
+    /// <summary>
+    /// Assigned draft id.
+    /// </summary>
+    public string DraftId { get; set; }
+
+    /// <summary>
+    /// Whether this mail is only created locally.
+    /// </summary>
+    [Ignore]
+    public bool IsLocalDraft => !string.IsNullOrEmpty(DraftId) && DraftId.StartsWith(Constants.LocalDraftStartPrefix);
+
+    /// <summary>
+    /// Whether this copy is draft or not.
+    /// </summary>
+    public bool IsDraft { get; set; }
+
+    /// <summary>
+    /// File id that this mail is assigned to.
+    /// This Id is immutable. It's used to find the file in the file system.
+    /// Even after mapping local draft to remote draft, it will not change.
+    /// </summary>
+    public Guid FileId { get; set; }
+
+    /// <summary>
+    /// Folder that this mail is assigned to.
+    /// Warning: This field is not populated by queries.
+    /// Services or View Models are responsible for populating this field.
+    /// </summary>
+    [Ignore]
+    public MailItemFolder AssignedFolder { get; set; }
+
+    /// <summary>
+    /// Account that this mail is assigned to.
+    /// Warning: This field is not populated by queries.
+    /// Services or View Models are responsible for populating this field.
+    /// </summary>
+    [Ignore]
+    public MailAccount AssignedAccount { get; set; }
+
+    /// <summary>
+    /// Contact information of the sender if exists.
+    /// Warning: This field is not populated by queries.
+    /// Services or View Models are responsible for populating this field.
+    /// </summary>
+    [Ignore]
+    public AccountContact SenderContact { get; set; }
+
+    [Ignore]
+    public bool IsReadReceiptRequested { get; set; }
+
+    [Ignore]
+    public SentMailReceiptStatus ReadReceiptStatus { get; set; }
+
+    [Ignore]
+    public DateTime? ReadReceiptAcknowledgedAtUtc { get; set; }
+
+    [Ignore]
+    public Guid? ReadReceiptMessageUniqueId { get; set; }
+
+    public IEnumerable<Guid> GetContainingIds() => [UniqueId];
+    public override string ToString() => $"{Subject} <-> {Id}";
+}

Wino.Core.Domain/Entities/Mail/MailInvitationCalendarMapping.cs

@@ -0,0 +1,31 @@
+using System;
+using SQLite;
+
+namespace Wino.Core.Domain.Entities.Mail;
+
+/// <summary>
+/// Maps a calendar invitation mail item to a persisted calendar event.
+/// </summary>
+public class MailInvitationCalendarMapping
+{
+    [PrimaryKey]
+    public Guid Id { get; set; }
+
+    public Guid AccountId { get; set; }
+
+    /// <summary>
+    /// MailCopy.Id value of the invitation mail.
+    /// </summary>
+    public string MailCopyId { get; set; }
+
+    /// <summary>
+    /// iCalendar UID extracted from invitation MIME/ICS content.
+    /// </summary>
+    public string InvitationUid { get; set; }
+
+    public Guid CalendarId { get; set; }
+    public Guid CalendarItemId { get; set; }
+    public string CalendarRemoteEventId { get; set; }
+
+    public DateTime UpdatedAtUtc { get; set; } = DateTime.UtcNow;
+}

Wino.Core.Domain/Entities/Mail/MailItemFolder.cs

@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using SQLite;
+using Wino.Core.Domain.Enums;
+using Wino.Core.Domain.Models.Folders;
+
+namespace Wino.Core.Domain.Entities.Mail;
+
+[DebuggerDisplay("{FolderName} - {SpecialFolderType}")]
+public class MailItemFolder : IMailItemFolder
+{
+    [PrimaryKey]
+    public Guid Id { get; set; }
+
+    public string RemoteFolderId { get; set; }
+    public string ParentRemoteFolderId { get; set; }
+
+    public Guid MailAccountId { get; set; }
+    public string FolderName { get; set; }
+    public SpecialFolderType SpecialFolderType { get; set; }
+    public bool IsSystemFolder { get; set; }
+    public bool IsSticky { get; set; }
+    public bool IsSynchronizationEnabled { get; set; }
+    public bool IsHidden { get; set; }
+    public bool ShowUnreadCount { get; set; }
+
+    // User-defined ordering within its navigation section (Pinned / Categories / More).
+    // 0 means "no custom order set" — the folder falls back to the default sort
+    // (alphabetic for More, canonical SpecialFolderType order as a tiebreak for Pinned).
+    public int Order { get; set; }
+    public DateTime? LastSynchronizedDate { get; set; }
+
+    // For IMAP
+    public uint UidValidity { get; set; }
+    public long HighestModeSeq { get; set; }
+    public uint HighestKnownUid { get; set; }
+    public DateTime? LastUidReconcileUtc { get; set; }
+
+    /// <summary>
+    /// Outlook shares delta changes per-folder. Gmail is for per-account.
+    /// This is only used for Outlook provider.
+    /// </summary>
+    public string DeltaToken { get; set; }
+
+    // For GMail Labels
+    public string TextColorHex { get; set; }
+    public string BackgroundColorHex { get; set; }
+
+    [Ignore]
+    public List<IMailItemFolder> ChildFolders { get; set; } = [];
+
+    // Category and Move type folders are not valid move targets.
+    // These folders are virtual. They don't exist on the server.
+    public bool IsMoveTarget => !(SpecialFolderType == SpecialFolderType.More || SpecialFolderType == SpecialFolderType.Category);
+
+    public bool ContainsSpecialFolderType(SpecialFolderType type)
+    {
+        if (SpecialFolderType == type)
+            return true;
+
+        foreach (var child in ChildFolders)
+        {
+            if (child.SpecialFolderType == type)
+            {
+                return true;
+            }
+            else
+            {
+                return child.ContainsSpecialFolderType(type);
+            }
+        }
+
+        return false;
+    }
+
+    public static MailItemFolder CreateMoreFolder() => new MailItemFolder() { IsSticky = true, SpecialFolderType = SpecialFolderType.More, FolderName = Translator.MoreFolderNameOverride };
+    public static MailItemFolder CreateCategoriesFolder() => new MailItemFolder() { IsSticky = true, SpecialFolderType = SpecialFolderType.Category, FolderName = Translator.CategoriesFolderNameOverride };
+
+    public override string ToString() => FolderName;
+}

Wino.Core.Domain/Entities/Mail/MergedInbox.cs

@@ -0,0 +1,12 @@
+using System;
+using SQLite;
+
+namespace Wino.Core.Domain.Entities.Mail;
+
+public class MergedInbox
+{
+    [PrimaryKey]
+    public Guid Id { get; set; }
+
+    public string Name { get; set; }
+}

Wino.Core.Domain/Entities/Mail/SentMailReceiptState.cs

@@ -0,0 +1,25 @@
+using System;
+using SQLite;
+using Wino.Core.Domain.Enums;
+
+namespace Wino.Core.Domain.Entities.Mail;
+
+public class SentMailReceiptState
+{
+    [PrimaryKey]
+    public Guid MailUniqueId { get; set; }
+
+    public Guid AccountId { get; set; }
+
+    public string MessageId { get; set; }
+
+    public bool IsReceiptRequested { get; set; }
+
+    public DateTime RequestedAtUtc { get; set; }
+
+    public SentMailReceiptStatus Status { get; set; }
+
+    public DateTime? AcknowledgedAtUtc { get; set; }
+
+    public Guid? ReceiptMessageUniqueId { get; set; }
+}

Wino.Core.Domain/Entities/MailAccount.cs

@@ -1,82 +0,0 @@
-using System;
-using SQLite;
-using Wino.Core.Domain.Enums;
-
-namespace Wino.Core.Domain.Entities
-{
-    public class MailAccount
-    {
-        [PrimaryKey]
-        public Guid Id { get; set; }
-
-        /// <summary>
-        /// Given name of the account in Wino.
-        /// </summary>
-        public string Name { get; set; }
-
-        /// <summary>
-        /// TODO: Display name of the authenticated user/account.
-        /// API integrations will query this value from the API.
-        /// IMAP is populated by user on setup dialog.
-        /// </summary>
-
-        public string SenderName { get; set; }
-
-        /// <summary>
-        /// Account e-mail address.
-        /// </summary>
-        public string Address { get; set; }
-
-        /// <summary>
-        /// Provider type of the account. Outlook,Gmail etc...
-        /// </summary>
-        public MailProviderType ProviderType { get; set; }
-
-        /// <summary>
-        /// For tracking change delta.
-        /// Gmail  : historyId
-        /// Outlook: deltaToken
-        /// </summary>
-        public string SynchronizationDeltaIdentifier { get; set; }
-
-        /// <summary>
-        /// TODO: Gets or sets the custom account identifier color in hex.
-        /// </summary>
-        public string AccountColorHex { get; set; }
-
-        /// <summary>
-        /// Gets or sets the listing order of the account in the accounts list.
-        /// </summary>
-        public int Order { get; set; }
-
-        /// <summary>
-        /// Gets or sets whether the account has any reason for an interactive user action to fix continue operating.
-        /// </summary>
-        public AccountAttentionReason AttentionReason { get; set; }
-
-        /// <summary>
-        /// Gets or sets the id of the merged inbox this account belongs to.
-        /// </summary>
-        public Guid? MergedInboxId { get; set; }
-
-        /// <summary>
-        /// Contains the merged inbox this account belongs to.
-        /// Ignored for all SQLite operations.
-        /// </summary>
-        [Ignore]
-        public MergedInbox MergedInbox { get; set; }
-
-        /// <summary>
-        /// Populated only when account has custom server information.
-        /// </summary>
-
-        [Ignore]
-        public CustomServerInformation ServerInformation { get; set; }
-
-        /// <summary>
-        /// Account preferences.
-        /// </summary>
-        [Ignore]
-        public MailAccountPreferences Preferences { get; set; }
-    }
-}

Wino.Core.Domain/Entities/MailAccountPreferences.cs

@@ -1,49 +0,0 @@
-using System;
-using SQLite;
-
-namespace Wino.Core.Domain.Entities
-{
-    public class MailAccountPreferences
-    {
-        [PrimaryKey]
-        public Guid Id { get; set; }
-
-        /// <summary>
-        /// Id of the account in MailAccount table.
-        /// </summary>
-        public Guid AccountId { get; set; }
-
-        /// <summary>
-        /// Gets or sets whether sent draft messages should be appended to the sent folder.
-        /// Some IMAP servers do this automatically, some don't.
-        /// It's disabled by default.
-        /// </summary>
-        public bool ShouldAppendMessagesToSentFolder { get; set; }
-
-        /// <summary>
-        /// Gets or sets whether the notifications are enabled for the account.
-        /// </summary>
-        public bool IsNotificationsEnabled { get; set; }
-
-        /// <summary>
-        /// Gets or sets whether the account has Focused inbox support.
-        /// Null if the account provider type doesn't support Focused inbox.
-        /// </summary>
-        public bool? IsFocusedInboxEnabled { get; set; }
-
-        /// <summary>
-        /// Gets or sets whether signature should be appended automatically.
-        /// </summary>
-        public bool IsSignatureEnabled { get; set; }
-
-        /// <summary>
-        /// Gets or sets signature for new messages. Null if signature is not needed.
-        /// </summary>
-        public Guid? SignatureIdForNewMessages { get; set; }
-
-        /// <summary>
-        /// Gets or sets signature for following messages. Null if signature is not needed.
-        /// </summary>
-        public Guid? SignatureIdForFollowingMessages { get; set; }
-    }
-}

Wino.Core.Domain/Entities/MailCopy.cs

@@ -1,147 +0,0 @@
-using System;
-using System.Collections.Generic;
-using SQLite;
-using Wino.Core.Domain.Enums;
-using Wino.Core.Domain.Models.MailItem;
-
-namespace Wino.Core.Domain.Entities
-{
-    /// <summary>
-    /// Summary of the parsed MIME messages.
-    /// Wino will do non-network operations on this table and others from the original MIME.
-    /// </summary>
-    public class MailCopy : IMailItem
-    {
-        /// <summary>
-        /// Unique Id of the mail.
-        /// </summary>
-        [PrimaryKey]
-        public Guid UniqueId { get; set; }
-
-        /// <summary>
-        /// Not unique id of the item. Some operations held on this Id, some on the UniqueId.
-        /// Same message can be in different folder. In that case UniqueId is used.
-        /// </summary>
-        public string Id { get; set; }
-
-        /// <summary>
-        /// Folder that this mail belongs to.
-        /// </summary>
-        public Guid FolderId { get; set; }
-
-        /// <summary>
-        /// Conversation id for the mail.
-        /// </summary>
-        public string ThreadId { get; set; }
-
-        /// <summary>
-        /// MIME MessageId if exists.
-        /// </summary>
-        public string MessageId { get; set; }
-
-        /// <summary>
-        /// References header from MIME
-        /// </summary>
-        public string References { get; set; }
-
-        /// <summary>
-        /// In-Reply-To header from MIME
-        /// </summary>
-        public string InReplyTo { get; set; }
-
-        /// <summary>
-        /// Name for the sender.
-        /// </summary>
-        public string FromName { get; set; }
-
-        /// <summary>
-        /// Address of the sender.
-        /// </summary>
-        public string FromAddress { get; set; }
-
-        /// <summary>
-        /// Subject of the mail.
-        /// </summary>
-        public string Subject { get; set; }
-
-        /// <summary>
-        /// Short preview of the content.
-        /// </summary>
-        public string PreviewText { get; set; }
-
-        /// <summary>
-        /// Date that represents this mail has been created in provider servers.
-        /// Stored always in UTC.
-        /// </summary>
-        public DateTime CreationDate { get; set; }
-
-        /// <summary>
-        /// Importance of the mail.
-        /// </summary>
-        public MailImportance Importance { get; set; }
-
-        /// <summary>
-        /// Read status for the mail.
-        /// </summary>
-        public bool IsRead { get; set; }
-
-        /// <summary>
-        /// Flag status.
-        /// Flagged for Outlook.
-        /// Important for Gmail.
-        /// </summary>
-        public bool IsFlagged { get; set; }
-
-        /// <summary>
-        /// To support Outlook.
-        /// Gmail doesn't use it.
-        /// </summary>
-        public bool IsFocused { get; set; }
-
-        /// <summary>
-        /// Whether mail has attachments included or not.
-        /// </summary>
-        public bool HasAttachments { get; set; }
-
-        /// <summary>
-        /// Assigned draft id.
-        /// </summary>
-        public string DraftId { get; set; }
-
-        /// <summary>
-        /// Whether this mail is only created locally.
-        /// </summary>
-        [Ignore]
-        public bool IsLocalDraft => !string.IsNullOrEmpty(DraftId) && DraftId.StartsWith(Constants.LocalDraftStartPrefix);
-
-        /// <summary>
-        /// Whether this copy is draft or not.
-        /// </summary>
-        public bool IsDraft { get; set; }
-
-        /// <summary>
-        /// File id that this mail is assigned to.
-        /// This Id is immutable. It's used to find the file in the file system.
-        /// Even after mapping local draft to remote draft, it will not change.
-        /// </summary>
-        public Guid FileId { get; set; }
-
-        /// <summary>
-        /// Folder that this mail is assigned to.
-        /// Warning: This field is not populated by queries.
-        /// Services or View Models are responsible for populating this field.
-        /// </summary>
-        [Ignore]
-        public MailItemFolder AssignedFolder { get; set; }
-
-        /// <summary>
-        /// Account that this mail is assigned to.
-        /// Warning: This field is not populated by queries.
-        /// Services or View Models are responsible for populating this field.
-        /// </summary>
-        [Ignore]
-        public MailAccount AssignedAccount { get; set; }
-        public IEnumerable<Guid> GetContainingIds() => new[] { UniqueId };
-        public override string ToString() => $"{Subject} <-> {Id}";
-    }
-}

Wino.Core.Domain/Entities/MailItemFolder.cs

@@ -1,75 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using SQLite;
-using Wino.Core.Domain.Enums;
-using Wino.Core.Domain.Models.Folders;
-
-namespace Wino.Core.Domain.Entities
-{
-    [DebuggerDisplay("{FolderName} - {SpecialFolderType}")]
-    public class MailItemFolder : IMailItemFolder
-    {
-        [PrimaryKey]
-        public Guid Id { get; set; }
-
-        public string RemoteFolderId { get; set; }
-        public string ParentRemoteFolderId { get; set; }
-
-        public Guid MailAccountId { get; set; }
-        public string FolderName { get; set; }
-        public SpecialFolderType SpecialFolderType { get; set; }
-        public bool IsSystemFolder { get; set; }
-        public bool IsSticky { get; set; }
-        public bool IsSynchronizationEnabled { get; set; }
-        public bool IsHidden { get; set; }
-        public bool ShowUnreadCount { get; set; }
-        public DateTime? LastSynchronizedDate { get; set; }
-
-        // For IMAP
-        public uint UidValidity { get; set; }
-        public long HighestModeSeq { get; set; }
-
-        /// <summary>
-        /// Outlook shares delta changes per-folder. Gmail is for per-account.
-        /// This is only used for Outlook provider.
-        /// </summary>
-        public string DeltaToken { get; set; }
-
-        // For GMail Labels
-        public string TextColorHex { get; set; }
-        public string BackgroundColorHex { get; set; }
-
-        [Ignore]
-        public List<IMailItemFolder> ChildFolders { get; set; } = [];
-
-        // Category and Move type folders are not valid move targets.
-        // These folders are virtual. They don't exist on the server.
-        public bool IsMoveTarget => !(SpecialFolderType == SpecialFolderType.More || SpecialFolderType == SpecialFolderType.Category);
-
-        public bool ContainsSpecialFolderType(SpecialFolderType type)
-        {
-            if (SpecialFolderType == type)
-                return true;
-
-            foreach (var child in ChildFolders)
-            {
-                if (child.SpecialFolderType == type)
-                {
-                    return true;
-                }
-                else
-                {
-                    return child.ContainsSpecialFolderType(type);
-                }
-            }
-
-            return false;
-        }
-
-        public static MailItemFolder CreateMoreFolder() => new MailItemFolder() { IsSticky = true, SpecialFolderType = SpecialFolderType.More, FolderName = Translator.MoreFolderNameOverride };
-        public static MailItemFolder CreateCategoriesFolder() => new MailItemFolder() { IsSticky = true, SpecialFolderType = SpecialFolderType.Category, FolderName = Translator.CategoriesFolderNameOverride };
-
-        public override string ToString() => FolderName;
-    }
-}

Wino.Core.Domain/Entities/MergedInbox.cs

@@ -1,13 +0,0 @@
-using System;
-using SQLite;
-
-namespace Wino.Core.Domain.Entities
-{
-    public class MergedInbox
-    {
-        [PrimaryKey]
-        public Guid Id { get; set; }
-
-        public string Name { get; set; }
-    }
-}

Wino.Core.Domain/Entities/Shared/AccountContact.cs

@@ -0,0 +1,75 @@
+using System;
+using System.Collections.Generic;
+using SQLite;
+
+namespace Wino.Core.Domain.Entities.Shared;
+
+/// <summary>
+/// Back storage for simple name-address book.
+/// These values will be inserted during MIME fetch.
+/// </summary>
+
+// TODO: This can easily evolve to Contact store, just like People app in Windows 10/11.
+// Do it.
+public class AccountContact : IEquatable<AccountContact>, IContactDisplayItem
+{
+    /// <summary>
+    /// E-mail address of the contact.
+    /// </summary>
+    [PrimaryKey]
+    public string Address { get; set; }
+
+    /// <summary>
+    /// Display name of the contact.
+    /// </summary>
+    public string Name { get; set; }
+
+    /// <summary>
+    /// File ID for the contact picture stored on disk.
+    /// The actual file lives at {ApplicationDataFolderPath}/contacts/{ContactPictureFileId}.jpg.
+    /// </summary>
+    public Guid? ContactPictureFileId { get; set; }
+
+    /// <summary>
+    /// All registered accounts have their contacts registered as root.
+    /// Root contacts must not be overridden by any configuration.
+    /// They are created on account creation.
+    /// </summary>
+    public bool IsRootContact { get; set; }
+
+    /// <summary>
+    /// When true, indicates that the contact has been manually modified by the user.
+    /// Contacts with this flag set to true should not be updated during synchronization.
+    /// </summary>
+    public bool IsOverridden { get; set; } = false;
+
+    public string DisplayName => string.IsNullOrWhiteSpace(Name) ? Address : Name;
+    AccountContact IContactDisplayItem.PreviewContact => this;
+
+    public override bool Equals(object obj)
+    {
+        return Equals(obj as AccountContact);
+    }
+
+    public bool Equals(AccountContact other)
+    {
+        return other is not null &&
+               Address == other.Address &&
+               Name == other.Name;
+    }
+
+    public override int GetHashCode()
+    {
+        return HashCode.Combine(Address, Name);
+    }
+
+    public static bool operator ==(AccountContact left, AccountContact right)
+    {
+        return EqualityComparer<AccountContact>.Default.Equals(left, right);
+    }
+
+    public static bool operator !=(AccountContact left, AccountContact right)
+    {
+        return !(left == right);
+    }
+}

Wino.Core.Domain/Entities/Shared/ContactGroup.cs

@@ -0,0 +1,19 @@
+using System;
+using SQLite;
+
+namespace Wino.Core.Domain.Entities.Shared;
+
+/// <summary>
+/// A named group of contacts that can be expanded to individual addresses during mail composition.
+/// </summary>
+public class ContactGroup
+{
+    [PrimaryKey]
+    public Guid Id { get; set; }
+
+    /// <summary>Display name of the group (e.g., "Team Alpha", "Family").</summary>
+    public string Name { get; set; }
+
+    /// <summary>Optional description for the group.</summary>
+    public string Description { get; set; }
+}

Wino.Core.Domain/Entities/Shared/ContactGroupMember.cs

@@ -0,0 +1,21 @@
+using System;
+using SQLite;
+
+namespace Wino.Core.Domain.Entities.Shared;
+
+/// <summary>
+/// Associates an e-mail address with a <see cref="ContactGroup"/>.
+/// </summary>
+public class ContactGroupMember
+{
+    [PrimaryKey, AutoIncrement]
+    public int Id { get; set; }
+
+    /// <summary>Group this member belongs to.</summary>
+    [Indexed]
+    public Guid GroupId { get; set; }
+
+    /// <summary>E-mail address of the member (FK to AccountContact.Address).</summary>
+    [Indexed]
+    public string MemberAddress { get; set; }
+}

Wino.Core.Domain/Entities/Shared/CustomServerInformation.cs

@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using SQLite;
+using Wino.Core.Domain.Enums;
+
+namespace Wino.Core.Domain.Entities.Shared;
+
+public class CustomServerInformation
+{
+    [PrimaryKey]
+    public Guid Id { get; set; }
+
+    public Guid AccountId { get; set; }
+
+    /// <summary>
+    /// This field is ignored. DisplayName is stored in MailAccount as SenderName from now.
+    /// </summary>
+    [Ignore]
+    public string DisplayName { get; set; }
+    public string Address { get; set; }
+    public string IncomingServer { get; set; }
+    public string IncomingServerUsername { get; set; }
+    public string IncomingServerPassword { get; set; }
+    public string IncomingServerPort { get; set; }
+
+    public CustomIncomingServerType IncomingServerType { get; set; }
+
+    public string OutgoingServer { get; set; }
+    public string OutgoingServerPort { get; set; }
+    public string OutgoingServerUsername { get; set; }
+    public string OutgoingServerPassword { get; set; }
+
+    public string CalDavServiceUrl { get; set; }
+    public string CalDavUsername { get; set; }
+    public string CalDavPassword { get; set; }
+    public ImapCalendarSupportMode CalendarSupportMode { get; set; }
+
+    /// <summary>
+    /// useSSL True: SslOnConnect
+    /// useSSL False: StartTlsWhenAvailable
+    /// </summary>
+
+    public ImapConnectionSecurity IncomingServerSocketOption { get; set; }
+    public ImapAuthenticationMethod IncomingAuthenticationMethod { get; set; }
+
+
+    public ImapConnectionSecurity OutgoingServerSocketOption { get; set; }
+    public ImapAuthenticationMethod OutgoingAuthenticationMethod { get; set; }
+
+    public string ProxyServer { get; set; }
+    public string ProxyServerPort { get; set; }
+
+    /// <summary>
+    /// Number of concurrent clients that can connect to the server.
+    /// Default is 5.
+    /// </summary>
+    public int MaxConcurrentClients { get; set; }
+
+    public Dictionary<string, string> GetConnectionProperties()
+    {
+        // Printout the public connection properties.
+
+        var connectionProperties = new Dictionary<string, string>
+        {
+            { "IncomingServer", IncomingServer },
+            { "IncomingServerPort", IncomingServerPort },
+            { "IncomingServerSocketOption", IncomingServerSocketOption.ToString() },
+            { "IncomingAuthenticationMethod", IncomingAuthenticationMethod.ToString() },
+            { "OutgoingServer", OutgoingServer },
+            { "OutgoingServerPort", OutgoingServerPort },
+            { "OutgoingServerSocketOption", OutgoingServerSocketOption.ToString() },
+            { "OutgoingAuthenticationMethod", OutgoingAuthenticationMethod.ToString() },
+            { "CalendarSupportMode", CalendarSupportMode.ToString() },
+            { "CalDavServiceUrl", CalDavServiceUrl },
+            { "ProxyServer", ProxyServer },
+            { "ProxyServerPort", ProxyServerPort }
+        };
+
+        return connectionProperties;
+    }
+}

Wino.Core.Domain/Entities/Shared/IContactDisplayItem.cs

@@ -0,0 +1,8 @@
+namespace Wino.Core.Domain.Entities.Shared;
+
+public interface IContactDisplayItem
+{
+    string DisplayName { get; }
+    string Address { get; }
+    AccountContact PreviewContact { get; }
+}

Wino.Core.Domain/Entities/Shared/KeyboardShortcut.cs

@@ -0,0 +1,65 @@
+using System;
+using SQLite;
+using Wino.Core.Domain.Enums;
+
+namespace Wino.Core.Domain.Entities.Shared;
+
+/// <summary>
+/// Represents a user-defined keyboard shortcut for mail operations.
+/// </summary>
+public class KeyboardShortcut
+{
+    [PrimaryKey]
+    public Guid Id { get; set; }
+
+    /// <summary>
+    /// The application mode this shortcut applies to.
+    /// </summary>
+    public WinoApplicationMode Mode { get; set; } = WinoApplicationMode.Mail;
+
+    /// <summary>
+    /// The key combination string (e.g., "D", "Delete", "F1").
+    /// </summary>
+    public string Key { get; set; }
+
+    /// <summary>
+    /// The modifier keys for this shortcut.
+    /// </summary>
+    public ModifierKeys ModifierKeys { get; set; }
+
+    /// <summary>
+    /// The shortcut action this shortcut triggers.
+    /// </summary>
+    public KeyboardShortcutAction Action { get; set; }
+
+    /// <summary>
+    /// Whether this shortcut is enabled.
+    /// </summary>
+    public bool IsEnabled { get; set; } = true;
+
+    /// <summary>
+    /// When this shortcut was created.
+    /// </summary>
+    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
+
+    /// <summary>
+    /// User-friendly display name for the shortcut.
+    /// </summary>
+    public string DisplayName 
+    { 
+        get 
+        {
+            var modifierText = string.Empty;
+            if (ModifierKeys.HasFlag(ModifierKeys.Control))
+                modifierText += "Ctrl+";
+            if (ModifierKeys.HasFlag(ModifierKeys.Alt))
+                modifierText += "Alt+";
+            if (ModifierKeys.HasFlag(ModifierKeys.Shift))
+                modifierText += "Shift+";
+            if (ModifierKeys.HasFlag(ModifierKeys.Windows))
+                modifierText += "Win+";
+
+            return modifierText + Key;
+        }
+    }
+}

Wino.Core.Domain/Entities/Shared/MailAccount.cs

@@ -0,0 +1,148 @@
+using System;
+using SQLite;
+using Wino.Core.Domain.Entities.Mail;
+using Wino.Core.Domain.Enums;
+
+namespace Wino.Core.Domain.Entities.Shared;
+
+public class MailAccount
+{
+    [PrimaryKey]
+    public Guid Id { get; set; }
+
+    /// <summary>
+    /// Given name of the account in Wino.
+    /// </summary>
+    public string Name { get; set; }
+
+    /// <summary>
+    /// TODO: Display name of the authenticated user/account.
+    /// API integrations will query this value from the API.
+    /// IMAP is populated by user on setup dialog.
+    /// </summary>
+
+    public string SenderName { get; set; }
+
+    /// <summary>
+    /// Account e-mail address.
+    /// </summary>
+    public string Address { get; set; }
+
+    /// <summary>
+    /// Provider type of the account. Outlook,Gmail etc...
+    /// </summary>
+    public MailProviderType ProviderType { get; set; }
+
+    /// <summary>
+    /// For tracking mail change delta.
+    /// Gmail  : historyId
+    /// Outlook: deltaToken
+    /// </summary>
+    public string SynchronizationDeltaIdentifier { get; set; }
+
+    /// <summary>
+    /// For tracking calendar change delta.
+    /// Gmail: It's per-calendar, so unused.
+    /// Outlook: deltaLink
+    /// </summary>
+    public string CalendarSynchronizationDeltaIdentifier { get; set; }
+
+    /// <summary>
+    /// TODO: Gets or sets the custom account identifier color in hex.
+    /// </summary>
+    public string AccountColorHex { get; set; }
+
+    /// <summary>
+    /// Base64 encoded profile picture of the account.
+    /// </summary>
+    public string Base64ProfilePictureData { get; set; }
+
+    /// <summary>
+    /// Gets or sets the listing order of the account in the accounts list.
+    /// </summary>
+    public int Order { get; set; }
+
+    /// <summary>
+    /// Gets or sets whether the account has any reason for an interactive user action to fix continue operating.
+    /// </summary>
+    public AccountAttentionReason AttentionReason { get; set; }
+
+    /// <summary>
+    /// Gets or sets the id of the merged inbox this account belongs to.
+    /// </summary>
+    public Guid? MergedInboxId { get; set; }
+
+    /// <summary>
+    /// Gets or sets the additional IMAP provider assignment for the account.
+    /// Providers that use IMAP as a synchronizer but have special requirements.
+    /// </summary>
+    public SpecialImapProvider SpecialImapProvider { get; set; }
+
+    /// <summary>
+    /// Gets or sets whether mail access is granted for this account.
+    /// When false, mail folders, aliases, compose flows, and mail synchronization are unavailable.
+    /// Default is true for legacy accounts to preserve existing behavior.
+    /// </summary>
+    public bool IsMailAccessGranted { get; set; } = true;
+
+    /// <summary>
+    /// Gets or sets whether calendar access is granted for this account.
+    /// When false, synchronizers will not process EventMessages or calendar invitations.
+    /// Default is false for existing accounts to prevent scope issues.
+    /// New accounts created after this feature will have this set to true.
+    /// </summary>
+    public bool IsCalendarAccessGranted { get; set; }
+
+    /// <summary>
+    /// Contains the merged inbox this account belongs to.
+    /// Ignored for all SQLite operations.
+    /// </summary>
+    [Ignore]
+    public MergedInbox MergedInbox { get; set; }
+
+    /// <summary>
+    /// Populated only when account has custom server information.
+    /// </summary>
+
+    [Ignore]
+    public CustomServerInformation ServerInformation { get; set; }
+
+    /// <summary>
+    /// Account preferences.
+    /// </summary>
+    [Ignore]
+    public MailAccountPreferences Preferences { get; set; }
+
+    /// <summary>
+    /// Last time folder structure was synchronized.
+    /// Used for optimization - skip folder sync if synced recently.
+    /// </summary>
+    public DateTime? LastFolderStructureSyncDate { get; set; }
+
+    /// <summary>
+    /// Gets or sets when the account was created in Wino.
+    /// </summary>
+    public DateTime? CreatedAt { get; set; }
+
+    /// <summary>
+    /// Gets or sets the timespan used for the account's initial mail synchronization.
+    /// </summary>
+    public InitialSynchronizationRange InitialSynchronizationRange { get; set; } = InitialSynchronizationRange.SixMonths;
+
+    /// <summary>
+    /// Gets whether the account can perform ProfileInformation sync type.
+    /// </summary>
+    public bool IsProfileInfoSyncSupported => ProviderType == MailProviderType.Outlook || ProviderType == MailProviderType.Gmail;
+
+    /// <summary>
+    /// Gets whether the account can perform AliasInformation sync type.
+    /// </summary>
+    public bool IsAliasSyncSupported => ProviderType == MailProviderType.Gmail || ProviderType == MailProviderType.Outlook;
+
+    /// <summary>
+    /// Gets whether the account can perform category definition sync type.
+    /// </summary>
+    public bool IsCategorySyncSupported => ProviderType == MailProviderType.Outlook;
+
+    public override string ToString() => Name;
+}

Wino.Core.Domain/Entities/Shared/MailAccountPreferences.cs

@@ -0,0 +1,53 @@
+using System;
+using SQLite;
+
+namespace Wino.Core.Domain.Entities.Shared;
+
+public class MailAccountPreferences
+{
+    [PrimaryKey]
+    public Guid Id { get; set; }
+
+    /// <summary>
+    /// Id of the account in MailAccount table.
+    /// </summary>
+    public Guid AccountId { get; set; }
+
+    /// <summary>
+    /// Gets or sets whether sent draft messages should be appended to the sent folder.
+    /// Some IMAP servers do this automatically, some don't.
+    /// It's disabled by default.
+    /// </summary>
+    public bool ShouldAppendMessagesToSentFolder { get; set; }
+
+    /// <summary>
+    /// Gets or sets whether the notifications are enabled for the account.
+    /// </summary>
+    public bool IsNotificationsEnabled { get; set; }
+
+    /// <summary>
+    /// Gets or sets whether the account has Focused inbox support.
+    /// Null if the account provider type doesn't support Focused inbox.
+    /// </summary>
+    public bool? IsFocusedInboxEnabled { get; set; }
+
+    /// <summary>
+    /// Gets or sets whether signature should be appended automatically.
+    /// </summary>
+    public bool IsSignatureEnabled { get; set; }
+
+    /// <summary>
+    /// Gets or sets whether this account's unread items should be included in taskbar badge.
+    /// </summary>
+    public bool IsTaskbarBadgeEnabled { get; set; } = true;
+
+    /// <summary>
+    /// Gets or sets signature for new messages. Null if signature is not needed.
+    /// </summary>
+    public Guid? SignatureIdForNewMessages { get; set; }
+
+    /// <summary>
+    /// Gets or sets signature for following messages. Null if signature is not needed.
+    /// </summary>
+    public Guid? SignatureIdForFollowingMessages { get; set; }
+}

Wino.Core.Domain/Entities/Shared/Thumbnail.cs

@@ -0,0 +1,14 @@
+using System;
+using SQLite;
+
+namespace Wino.Core.Domain.Entities.Shared;
+
+public class Thumbnail
+{
+    [PrimaryKey]
+    public string Domain { get; set; }
+
+    public string Gravatar { get; set; }
+    public string Favicon { get; set; }
+    public DateTime LastUpdated { get; set; }
+}

Wino.Core.Domain/Entities/Shared/WinoAccount.cs

@@ -0,0 +1,30 @@
+using System;
+using SQLite;
+
+namespace Wino.Core.Domain.Entities.Shared;
+
+public class WinoAccount
+{
+    [PrimaryKey]
+    public Guid Id { get; set; }
+
+    public string Email { get; set; } = string.Empty;
+
+    public string AccountStatus { get; set; } = string.Empty;
+
+    public bool HasPassword { get; set; }
+
+    public bool HasGoogleLogin { get; set; }
+
+    public bool HasFacebookLogin { get; set; }
+
+    public string AccessToken { get; set; } = string.Empty;
+
+    public DateTime AccessTokenExpiresAtUtc { get; set; }
+
+    public string RefreshToken { get; set; } = string.Empty;
+
+    public DateTime RefreshTokenExpiresAtUtc { get; set; }
+
+    public DateTime LastAuthenticatedUtc { get; set; }
+}

Wino.Core.Domain/Entities/SystemFolderConfiguration.cs

@@ -1,12 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace Wino.Core.Domain.Entities
-{
-    public record SystemFolderConfiguration(MailItemFolder SentFolder,
-                                            MailItemFolder DraftFolder,
-                                            MailItemFolder ArchiveFolder,
-                                            MailItemFolder TrashFolder,
-                                            MailItemFolder JunkFolder);
-}

Wino.Core.Domain/Entities/TokenInformation.cs

@@ -1,30 +0,0 @@
-using System;
-using SQLite;
-using Wino.Core.Domain.Models.Authentication;
-
-namespace Wino.Core.Domain.Entities
-{
-    public class TokenInformation : TokenInformationBase
-    {
-        [PrimaryKey]
-        public Guid Id { get; set; }
-
-        public Guid AccountId { get; set; }
-
-        /// <summary>
-        /// Unique object storage for authenticators if needed.
-        /// </summary>
-        public string UniqueId { get; set; }
-        public string Address { get; set; }
-
-        public void RefreshTokens(TokenInformationBase tokenInformationBase)
-        {
-            if (tokenInformationBase == null)
-                throw new ArgumentNullException(nameof(tokenInformationBase));
-
-            AccessToken = tokenInformationBase.AccessToken;
-            RefreshToken = tokenInformationBase.RefreshToken;
-            ExpiresAt = tokenInformationBase.ExpiresAt;
-        }
-    }
-}

Wino.Core.Domain/Enums/AccountAttentionReason.cs

@@ -1,9 +1,8 @@
-namespace Wino.Core.Domain.Enums
+namespace Wino.Core.Domain.Enums;
+
+public enum AccountAttentionReason
 {
-    public enum AccountAttentionReason
-    {
-        None,
-        InvalidCredentials,
-        MissingSystemFolderConfiguration
-    }
+    None,
+    InvalidCredentials,
+    MissingSystemFolderConfiguration
 }

Wino.Core.Domain/Enums/AccountCacheResetReason.cs

@@ -0,0 +1,7 @@
+namespace Wino.Core.Domain.Enums;
+
+public enum AccountCacheResetReason
+{
+    AccountRemoval,
+    ExpiredCache
+}