diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 176d74d0c557a9c1ea95338eb353642c18cd44c6..d1d38295a66f494563427c5f7738986d58f6085d 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -1,4 +1,4 @@
-image: "registry.gitlab.e.foundation/e/os/docker-android-apps-cicd:1263-Add_java_17_support"
+image: "registry.gitlab.e.foundation/e/os/docker-android-apps-cicd:master"
 
 stages:
 - update-from-upstream
diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index cf554d3866682b76afe250feee828cd50404752c..0858e3ff9b610f022045807728d1163c6d00c4e3 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -20,11 +20,6 @@
       </option>
     </JavaCodeStyleSettings>
     <JetCodeStyleSettings>
-      <option name="PACKAGES_TO_USE_STAR_IMPORTS">
-        <value>
-          <package name="kotlinx.android.synthetic" alias="false" withSubpackages="true" />
-        </value>
-      </option>
       <option name="PACKAGES_IMPORT_LAYOUT">
         <value>
           <package name="" alias="false" withSubpackages="true" />
diff --git a/app-feature-preview/build.gradle.kts b/app-feature-preview/build.gradle.kts
index b8661a101b0658b46ad83a8081395cfc445247f5..b601ae760fa3656afc643a2863541d97cb336112 100644
--- a/app-feature-preview/build.gradle.kts
+++ b/app-feature-preview/build.gradle.kts
@@ -9,12 +9,67 @@ android {
         applicationId = "net.thunderbird.feature.preview"
         versionCode = 1
         versionName = "1.0"
+
+        buildConfigField(
+            "String",
+            "OAUTH_GMAIL_CLIENT_ID",
+            "\"262622259280-5qb3vtj68d5dtudmaif4g9vd3cpar8r3.apps.googleusercontent.com\"",
+        )
+        buildConfigField(
+            "String",
+            "OAUTH_YAHOO_CLIENT_ID",
+            "\"dj0yJmk9ejRCRU1ybmZjQlVBJmQ9WVdrOVVrZEViak4xYmxZbWNHbzlNQT09JnM9Y29uc3VtZXJzZWNyZXQmc3Y9MCZ4PTZj\"",
+        )
+        buildConfigField(
+            "String",
+            "OAUTH_AOL_CLIENT_ID",
+            "\"dj0yJmk9cHYydkJkTUxHcXlYJmQ9WVdrOWVHZHhVVXN4VVV3bWNHbzlNQT09JnM9Y29uc3VtZXJzZWNyZXQmc3Y9MCZ4PTdm\"",
+        )
+        buildConfigField(
+            "String",
+            "OAUTH_MICROSOFT_CLIENT_ID",
+            "\"e647013a-ada4-4114-b419-e43d250f99c5\"",
+        )
+        buildConfigField(
+            "String",
+            "OAUTH_MICROSOFT_REDIRECT_URI_ID",
+            "\"VZF2DYuLYAu4TurFd6usQB2JPts%3D\"",
+        )
+
+        manifestPlaceholders["appAuthRedirectScheme"] = "com.fsck.k9.debug"
+    }
+
+    packaging {
+        resources {
+            excludes += listOf(
+                "META-INF/DEPENDENCIES",
+            )
+        }
+    }
+
+    buildTypes {
+        getByName("release") {
+            isMinifyEnabled = false
+            proguardFiles(
+                getDefaultProguardFile("proguard-android-optimize.txt"),
+                "proguard-rules.pro",
+            )
+            signingConfig = signingConfigs.getByName("debug")
+        }
+    }
+
+    lint {
+        baseline = file("lint-baseline.xml")
     }
 }
 
 dependencies {
     implementation(projects.core.ui.compose.designsystem)
+    implementation(projects.core.common)
+    implementation(projects.mail.common)
 
     implementation(projects.feature.onboarding)
     implementation(projects.feature.account.setup)
+    implementation(libs.okhttp)
+    implementation(libs.timber)
 }
diff --git a/app-feature-preview/lint-baseline.xml b/app-feature-preview/lint-baseline.xml
new file mode 100644
index 0000000000000000000000000000000000000000..5182475262024573d420d0e16ad978d8f9a00c48
--- /dev/null
+++ b/app-feature-preview/lint-baseline.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<issues format="6" by="lint 8.0.2" type="baseline" client="gradle" dependencies="true" name="AGP (8.0.2)" variant="all" version="8.0.2">
+
+    <issue
+        id="CustomX509TrustManager"
+        message="Implementing a custom `X509TrustManager` is error-prone and likely to be insecure. It is likely to disable certificate validation altogether, and is non-trivial to implement correctly without calling Android&apos;s default implementation."
+        errorLine1="    private class SecureX509TrustManager implements X509TrustManager {"
+        errorLine2="                  ~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/com/fsck/k9/mail/ssl/TrustManagerFactory.java"
+            line="70"
+            column="19"/>
+    </issue>
+
+</issues>
diff --git a/app-feature-preview/src/main/AndroidManifest.xml b/app-feature-preview/src/main/AndroidManifest.xml
index 5312e4e208ce682f897aea8a4f728dbe1b43afb7..1d43f40e5b1f5d1f8f44eff6209b35f045aa9378 100644
--- a/app-feature-preview/src/main/AndroidManifest.xml
+++ b/app-feature-preview/src/main/AndroidManifest.xml
@@ -1,23 +1,35 @@
 <?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+<manifest
+    xmlns:tools="http://schemas.android.com/tools"
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    >
+
+    <uses-permission android:name="android.permission.INTERNET"/>
 
     <application
+        android:name=".FeatureApplication"
         android:allowBackup="true"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
+        android:usesCleartextTraffic="true"
+        android:networkSecurityConfig="@xml/network_security_config"
         android:supportsRtl="true"
         android:theme="@style/Theme.Thunderbird.Splashscreen"
+        tools:ignore="UnusedAttribute"
         >
 
         <activity
             android:name=".FeatureActivity"
-            android:exported="true">
+            android:exported="true"
+            android:windowSoftInputMode="adjustResize"
+            >
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
 
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
         </activity>
+
     </application>
 
 </manifest>
diff --git a/app-feature-preview/src/main/java/app/k9mail/feature/preview/FeatureActivity.kt b/app-feature-preview/src/main/java/app/k9mail/feature/preview/FeatureActivity.kt
index 5963733647993e7a58d04d5fcc717269e3772b57..77c90b7a47d3d4e506c79191d769b8957fa4300f 100644
--- a/app-feature-preview/src/main/java/app/k9mail/feature/preview/FeatureActivity.kt
+++ b/app-feature-preview/src/main/java/app/k9mail/feature/preview/FeatureActivity.kt
@@ -2,9 +2,9 @@ package app.k9mail.feature.preview
 
 import android.os.Bundle
 import androidx.activity.ComponentActivity
-import androidx.activity.compose.setContent
 import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
 import androidx.core.view.WindowCompat
+import app.k9mail.core.ui.compose.common.activity.setActivityContent
 import app.k9mail.feature.preview.ui.FeatureApp
 
 class FeatureActivity : ComponentActivity() {
@@ -15,7 +15,7 @@ class FeatureActivity : ComponentActivity() {
 
         WindowCompat.setDecorFitsSystemWindows(window, false)
 
-        setContent {
+        setActivityContent {
             FeatureApp()
         }
     }
diff --git a/app-feature-preview/src/main/java/app/k9mail/feature/preview/FeatureApplication.kt b/app-feature-preview/src/main/java/app/k9mail/feature/preview/FeatureApplication.kt
new file mode 100644
index 0000000000000000000000000000000000000000..00c415908ae4539d35521cbd4228edb94be19952
--- /dev/null
+++ b/app-feature-preview/src/main/java/app/k9mail/feature/preview/FeatureApplication.kt
@@ -0,0 +1,17 @@
+package app.k9mail.feature.preview
+
+import android.app.Application
+import org.koin.android.ext.koin.androidContext
+import org.koin.core.context.startKoin
+
+class FeatureApplication : Application() {
+
+    override fun onCreate() {
+        super.onCreate()
+
+        startKoin {
+            androidContext(this@FeatureApplication)
+            modules(featureModule)
+        }
+    }
+}
diff --git a/app-feature-preview/src/main/java/app/k9mail/feature/preview/FeatureModule.kt b/app-feature-preview/src/main/java/app/k9mail/feature/preview/FeatureModule.kt
new file mode 100644
index 0000000000000000000000000000000000000000..23dd89e99409e66099f3d76c8f6647f2aae6268c
--- /dev/null
+++ b/app-feature-preview/src/main/java/app/k9mail/feature/preview/FeatureModule.kt
@@ -0,0 +1,32 @@
+package app.k9mail.feature.preview
+
+import app.k9mail.core.common.oauth.OAuthConfigurationFactory
+import app.k9mail.feature.account.setup.AccountSetupExternalContract
+import app.k9mail.feature.account.setup.featureAccountSetupModule
+import app.k9mail.feature.preview.account.AccountCreator
+import app.k9mail.feature.preview.account.AccountOwnerNameProvider
+import app.k9mail.feature.preview.auth.AndroidKeyStoreDirectoryProvider
+import app.k9mail.feature.preview.auth.AppOAuthConfigurationFactory
+import app.k9mail.feature.preview.auth.DefaultTrustedSocketFactory
+import com.fsck.k9.mail.ssl.KeyStoreDirectoryProvider
+import com.fsck.k9.mail.ssl.LocalKeyStore
+import com.fsck.k9.mail.ssl.TrustManagerFactory
+import com.fsck.k9.mail.ssl.TrustedSocketFactory
+import org.koin.core.module.Module
+import org.koin.dsl.module
+
+val accountModule: Module = module {
+    factory<AccountSetupExternalContract.AccountOwnerNameProvider> { AccountOwnerNameProvider() }
+    factory<AccountSetupExternalContract.AccountCreator> { AccountCreator() }
+}
+
+val featureModule: Module = module {
+    single<OAuthConfigurationFactory> { AppOAuthConfigurationFactory() }
+
+    factory<KeyStoreDirectoryProvider> { AndroidKeyStoreDirectoryProvider(context = get()) }
+    single { LocalKeyStore(directoryProvider = get()) }
+    single { TrustManagerFactory.createInstance(get()) }
+    single<TrustedSocketFactory> { DefaultTrustedSocketFactory(get(), get()) }
+
+    includes(featureAccountSetupModule, accountModule)
+}
diff --git a/app-feature-preview/src/main/java/app/k9mail/feature/preview/account/AccountCreator.kt b/app-feature-preview/src/main/java/app/k9mail/feature/preview/account/AccountCreator.kt
new file mode 100644
index 0000000000000000000000000000000000000000..51d9f8f40baf533c33653c962a3972d84579d117
--- /dev/null
+++ b/app-feature-preview/src/main/java/app/k9mail/feature/preview/account/AccountCreator.kt
@@ -0,0 +1,13 @@
+package app.k9mail.feature.preview.account
+
+import app.k9mail.feature.account.setup.AccountSetupExternalContract
+import app.k9mail.feature.account.setup.AccountSetupExternalContract.AccountCreator.AccountCreatorResult
+import app.k9mail.feature.account.setup.domain.entity.Account
+import java.util.UUID
+
+class AccountCreator : AccountSetupExternalContract.AccountCreator {
+
+    override suspend fun createAccount(account: Account): AccountCreatorResult {
+        return AccountCreatorResult.Success(UUID.randomUUID().toString())
+    }
+}
diff --git a/app-feature-preview/src/main/java/app/k9mail/feature/preview/account/AccountOwnerNameProvider.kt b/app-feature-preview/src/main/java/app/k9mail/feature/preview/account/AccountOwnerNameProvider.kt
new file mode 100644
index 0000000000000000000000000000000000000000..4e5b1c9aa652de7c9d6bb7a644c0c86e3bb58bad
--- /dev/null
+++ b/app-feature-preview/src/main/java/app/k9mail/feature/preview/account/AccountOwnerNameProvider.kt
@@ -0,0 +1,9 @@
+package app.k9mail.feature.preview.account
+
+import app.k9mail.feature.account.setup.AccountSetupExternalContract
+
+class AccountOwnerNameProvider : AccountSetupExternalContract.AccountOwnerNameProvider {
+    override suspend fun getOwnerName(): String? {
+        return null
+    }
+}
diff --git a/app-feature-preview/src/main/java/app/k9mail/feature/preview/auth/AndroidKeyStoreDirectoryProvider.kt b/app-feature-preview/src/main/java/app/k9mail/feature/preview/auth/AndroidKeyStoreDirectoryProvider.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c89fce2ac5542d59df5c06eccce6a3380af455bc
--- /dev/null
+++ b/app-feature-preview/src/main/java/app/k9mail/feature/preview/auth/AndroidKeyStoreDirectoryProvider.kt
@@ -0,0 +1,11 @@
+package app.k9mail.feature.preview.auth
+
+import android.content.Context
+import com.fsck.k9.mail.ssl.KeyStoreDirectoryProvider
+import java.io.File
+
+internal class AndroidKeyStoreDirectoryProvider(private val context: Context) : KeyStoreDirectoryProvider {
+    override fun getDirectory(): File {
+        return context.getDir("KeyStore", Context.MODE_PRIVATE)
+    }
+}
diff --git a/app-feature-preview/src/main/java/app/k9mail/feature/preview/auth/AppOAuthConfigurationFactory.kt b/app-feature-preview/src/main/java/app/k9mail/feature/preview/auth/AppOAuthConfigurationFactory.kt
new file mode 100644
index 0000000000000000000000000000000000000000..4a6313e0301aa9431b0dcbc54ff95ed2140e0d04
--- /dev/null
+++ b/app-feature-preview/src/main/java/app/k9mail/feature/preview/auth/AppOAuthConfigurationFactory.kt
@@ -0,0 +1,71 @@
+package app.k9mail.feature.preview.auth
+
+import app.k9mail.core.common.oauth.OAuthConfiguration
+import app.k9mail.core.common.oauth.OAuthConfigurationFactory
+import app.k9mail.feature.preview.BuildConfig
+
+class AppOAuthConfigurationFactory : OAuthConfigurationFactory {
+    override fun createConfigurations(): Map<List<String>, OAuthConfiguration> {
+        return mapOf(
+            createAolConfiguration(),
+            createGmailConfiguration(),
+            createMicrosoftConfiguration(),
+            createYahooConfiguration(),
+        )
+    }
+
+    private fun createAolConfiguration(): Pair<List<String>, OAuthConfiguration> {
+        return listOf("imap.aol.com", "smtp.aol.com") to OAuthConfiguration(
+            clientId = BuildConfig.OAUTH_AOL_CLIENT_ID,
+            scopes = listOf("mail-w"),
+            authorizationEndpoint = "https://api.login.aol.com/oauth2/request_auth",
+            tokenEndpoint = "https://api.login.aol.com/oauth2/get_token",
+            redirectUri = "${BuildConfig.APPLICATION_ID}://oauth2redirect",
+        )
+    }
+
+    private fun createGmailConfiguration(): Pair<List<String>, OAuthConfiguration> {
+        return listOf(
+            "imap.gmail.com",
+            "imap.googlemail.com",
+            "smtp.gmail.com",
+            "smtp.googlemail.com",
+        ) to OAuthConfiguration(
+            clientId = BuildConfig.OAUTH_GMAIL_CLIENT_ID,
+            scopes = listOf("https://mail.google.com/"),
+            authorizationEndpoint = "https://accounts.google.com/o/oauth2/v2/auth",
+            tokenEndpoint = "https://oauth2.googleapis.com/token",
+            redirectUri = "${BuildConfig.APPLICATION_ID}:/oauth2redirect",
+        )
+    }
+
+    private fun createMicrosoftConfiguration(): Pair<List<String>, OAuthConfiguration> {
+        return listOf(
+            "imap.mail.yahoo.com",
+            "smtp.mail.yahoo.com",
+        ) to OAuthConfiguration(
+            clientId = BuildConfig.OAUTH_MICROSOFT_CLIENT_ID,
+            scopes = listOf(
+                "https://outlook.office.com/IMAP.AccessAsUser.All",
+                "https://outlook.office.com/SMTP.Send",
+                "offline_access",
+            ),
+            authorizationEndpoint = "https://login.microsoftonline.com/common/oauth2/v2.0/authorize",
+            tokenEndpoint = "https://login.microsoftonline.com/common/oauth2/v2.0/token",
+            redirectUri = "msauth://${BuildConfig.APPLICATION_ID}://${BuildConfig.OAUTH_MICROSOFT_REDIRECT_URI_ID}",
+        )
+    }
+
+    private fun createYahooConfiguration(): Pair<List<String>, OAuthConfiguration> {
+        return listOf(
+            "imap.mail.yahoo.com",
+            "smtp.mail.yahoo.com",
+        ) to OAuthConfiguration(
+            clientId = BuildConfig.OAUTH_YAHOO_CLIENT_ID,
+            scopes = listOf("mail-w"),
+            authorizationEndpoint = "https://api.login.yahoo.com/oauth2/request_auth",
+            tokenEndpoint = "https://api.login.yahoo.com/oauth2/get_token",
+            redirectUri = "${BuildConfig.APPLICATION_ID}://oauth2redirect",
+        )
+    }
+}
diff --git a/app-feature-preview/src/main/java/app/k9mail/feature/preview/auth/DefaultTrustedSocketFactory.java b/app-feature-preview/src/main/java/app/k9mail/feature/preview/auth/DefaultTrustedSocketFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..d4781e899ba557570e9d0aa74aa7d38acc88f140
--- /dev/null
+++ b/app-feature-preview/src/main/java/app/k9mail/feature/preview/auth/DefaultTrustedSocketFactory.java
@@ -0,0 +1,167 @@
+package app.k9mail.feature.preview.auth;
+
+
+import java.io.IOException;
+import java.net.Socket;
+import java.security.KeyManagementException;
+import java.security.NoSuchAlgorithmException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import android.content.Context;
+import android.net.SSLCertificateSocketFactory;
+import android.os.Build;
+import android.text.TextUtils;
+
+import com.fsck.k9.mail.MessagingException;
+import com.fsck.k9.mail.ssl.TrustManagerFactory;
+import com.fsck.k9.mail.ssl.TrustedSocketFactory;
+import javax.net.ssl.KeyManager;
+import javax.net.ssl.SNIHostName;
+import javax.net.ssl.SNIServerName;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLParameters;
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.SSLSocketFactory;
+import javax.net.ssl.TrustManager;
+import timber.log.Timber;
+
+
+public class DefaultTrustedSocketFactory implements TrustedSocketFactory {
+    private static final String[] ENABLED_CIPHERS;
+    private static final String[] ENABLED_PROTOCOLS;
+
+    private static final String[] DISALLOWED_CIPHERS = {
+            "SSL_RSA_WITH_DES_CBC_SHA",
+            "SSL_DHE_RSA_WITH_DES_CBC_SHA",
+            "SSL_DHE_DSS_WITH_DES_CBC_SHA",
+            "SSL_RSA_EXPORT_WITH_RC4_40_MD5",
+            "SSL_RSA_EXPORT_WITH_DES40_CBC_SHA",
+            "SSL_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA",
+            "SSL_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA",
+            "SSL_RSA_WITH_3DES_EDE_CBC_SHA",
+            "SSL_DHE_RSA_WITH_3DES_EDE_CBC_SHA",
+            "SSL_DHE_DSS_WITH_3DES_EDE_CBC_SHA",
+            "TLS_ECDHE_RSA_WITH_RC4_128_SHA",
+            "TLS_ECDHE_ECDSA_WITH_RC4_128_SHA",
+            "TLS_ECDH_RSA_WITH_RC4_128_SHA",
+            "TLS_ECDH_ECDSA_WITH_RC4_128_SHA",
+            "SSL_RSA_WITH_RC4_128_SHA",
+            "SSL_RSA_WITH_RC4_128_MD5",
+            "TLS_ECDH_RSA_WITH_NULL_SHA",
+            "TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA",
+            "TLS_ECDH_anon_WITH_NULL_SHA",
+            "TLS_ECDH_anon_WITH_RC4_128_SHA",
+            "TLS_RSA_WITH_NULL_SHA256"
+    };
+
+    private static final String[] DISALLOWED_PROTOCOLS = {
+            "SSLv3"
+    };
+
+    static {
+        String[] enabledCiphers = null;
+        String[] supportedProtocols = null;
+
+        try {
+            SSLContext sslContext = SSLContext.getInstance("TLS");
+            sslContext.init(null, null, null);
+            SSLSocketFactory sf = sslContext.getSocketFactory();
+            SSLSocket sock = (SSLSocket) sf.createSocket();
+            enabledCiphers = sock.getEnabledCipherSuites();
+
+            /*
+             * Retrieve all supported protocols, not just the (default) enabled
+             * ones. TLSv1.1 & TLSv1.2 are supported on API levels 16+, but are
+             * only enabled by default on API levels 20+.
+             */
+            supportedProtocols = sock.getSupportedProtocols();
+        } catch (Exception e) {
+            Timber.e(e, "Error getting information about available SSL/TLS ciphers and protocols");
+        }
+
+        ENABLED_CIPHERS = (enabledCiphers == null) ? null : remove(enabledCiphers, DISALLOWED_CIPHERS);
+        ENABLED_PROTOCOLS = (supportedProtocols == null) ? null : remove(supportedProtocols, DISALLOWED_PROTOCOLS);
+    }
+
+    private final Context context;
+    private final TrustManagerFactory trustManagerFactory;
+
+    public DefaultTrustedSocketFactory(Context context, TrustManagerFactory trustManagerFactory) {
+        this.context = context;
+        this.trustManagerFactory = trustManagerFactory;
+    }
+
+    protected static String[] remove(String[] enabled, String[] disallowed) {
+        List<String> items = new ArrayList<>();
+        Collections.addAll(items, enabled);
+
+        if (disallowed != null) {
+            for (String item : disallowed) {
+                items.remove(item);
+            }
+        }
+
+        return items.toArray(new String[0]);
+    }
+
+    public Socket createSocket(Socket socket, String host, int port, String clientCertificateAlias)
+            throws NoSuchAlgorithmException, KeyManagementException, MessagingException, IOException {
+
+        TrustManager[] trustManagers = new TrustManager[] { trustManagerFactory.getTrustManagerForDomain(host, port) };
+        KeyManager[] keyManagers = null;
+        if (!TextUtils.isEmpty(clientCertificateAlias)) {
+            keyManagers = new KeyManager[] { new KeyChainKeyManager(context, clientCertificateAlias) };
+        }
+
+        SSLContext sslContext = SSLContext.getInstance("TLS");
+        sslContext.init(keyManagers, trustManagers, null);
+        SSLSocketFactory socketFactory = sslContext.getSocketFactory();
+        Socket trustedSocket;
+        if (socket == null) {
+            trustedSocket = socketFactory.createSocket();
+        } else {
+            trustedSocket = socketFactory.createSocket(socket, host, port, true);
+        }
+
+        SSLSocket sslSocket = (SSLSocket) trustedSocket;
+
+        hardenSocket(sslSocket);
+
+        setSniHost(socketFactory, sslSocket, host);
+
+        return trustedSocket;
+    }
+
+    private static void hardenSocket(SSLSocket sock) {
+        if (ENABLED_CIPHERS != null) {
+            sock.setEnabledCipherSuites(ENABLED_CIPHERS);
+        }
+        if (ENABLED_PROTOCOLS != null) {
+            sock.setEnabledProtocols(ENABLED_PROTOCOLS);
+        }
+    }
+
+    public static void setSniHost(SSLSocketFactory factory, SSLSocket socket, String hostname) {
+        if (factory instanceof SSLCertificateSocketFactory) {
+            SSLCertificateSocketFactory sslCertificateSocketFactory = (SSLCertificateSocketFactory) factory;
+            sslCertificateSocketFactory.setHostname(socket, hostname);
+        } else if (Build.VERSION.SDK_INT >= 24) {
+            SSLParameters sslParameters = socket.getSSLParameters();
+            List<SNIServerName> sniServerNames = Collections.singletonList(new SNIHostName(hostname));
+            sslParameters.setServerNames(sniServerNames);
+            socket.setSSLParameters(sslParameters);
+        } else {
+            setHostnameViaReflection(socket, hostname);
+        }
+    }
+
+    private static void setHostnameViaReflection(SSLSocket socket, String hostname) {
+        try {
+            socket.getClass().getMethod("setHostname", String.class).invoke(socket, hostname);
+        } catch (Throwable e) {
+            Timber.e(e, "Could not call SSLSocket#setHostname(String) method ");
+        }
+    }
+}
diff --git a/app-feature-preview/src/main/java/app/k9mail/feature/preview/auth/KeyChainKeyManager.java b/app-feature-preview/src/main/java/app/k9mail/feature/preview/auth/KeyChainKeyManager.java
new file mode 100644
index 0000000000000000000000000000000000000000..0242df8d4e422a3b588ae47ed65e812cfa470c37
--- /dev/null
+++ b/app-feature-preview/src/main/java/app/k9mail/feature/preview/auth/KeyChainKeyManager.java
@@ -0,0 +1,191 @@
+
+package app.k9mail.feature.preview.auth;
+
+
+import java.net.Socket;
+import java.security.Principal;
+import java.security.PrivateKey;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Locale;
+
+import android.content.Context;
+import android.security.KeyChain;
+import android.security.KeyChainException;
+
+import com.fsck.k9.mail.CertificateValidationException;
+import com.fsck.k9.mail.MessagingException;
+import javax.net.ssl.SSLEngine;
+import javax.net.ssl.X509ExtendedKeyManager;
+import javax.security.auth.x500.X500Principal;
+import timber.log.Timber;
+
+import static com.fsck.k9.mail.CertificateValidationException.Reason;
+import static com.fsck.k9.mail.CertificateValidationException.Reason.RetrievalFailure;
+
+
+/**
+ * For client certificate authentication! Provide private keys and certificates
+ * during the TLS handshake using the Android 4.0 KeyChain API.
+ */
+class KeyChainKeyManager extends X509ExtendedKeyManager {
+    private final String mAlias;
+    private final X509Certificate[] mChain;
+    private final PrivateKey mPrivateKey;
+
+
+    /**
+     * @param alias  Must not be null nor empty
+     * @throws MessagingException
+     *          Indicates an error in retrieving the certificate for the alias
+     *          (likely because the alias is invalid or the certificate was deleted)
+     */
+    public KeyChainKeyManager(Context context, String alias) throws MessagingException {
+        mAlias = alias;
+
+        try {
+            mChain = fetchCertificateChain(context, alias);
+            mPrivateKey = fetchPrivateKey(context, alias);
+        } catch (KeyChainException e) {
+            // The certificate was possibly deleted.  Notify user of error.
+            throw new CertificateValidationException(e.getMessage(), RetrievalFailure, alias);
+        } catch (InterruptedException e) {
+            throw new CertificateValidationException(e.getMessage(), RetrievalFailure, alias);
+        }
+    }
+
+    private X509Certificate[] fetchCertificateChain(Context context, String alias)
+            throws KeyChainException, InterruptedException, MessagingException {
+
+        X509Certificate[] chain = KeyChain.getCertificateChain(context, alias);
+        if (chain == null || chain.length == 0) {
+            throw new MessagingException("No certificate chain found for: " + alias);
+        }
+        try {
+            for (X509Certificate certificate : chain) {
+                certificate.checkValidity();
+            }
+        } catch (CertificateException e) {
+            throw new CertificateValidationException(e.getMessage(), Reason.Expired, alias);
+        }
+
+        return chain;
+    }
+
+    private PrivateKey fetchPrivateKey(Context context, String alias) throws KeyChainException,
+            InterruptedException, MessagingException {
+
+        PrivateKey privateKey = KeyChain.getPrivateKey(context, alias);
+        if (privateKey == null) {
+            throw new MessagingException("No private key found for: " + alias);
+        }
+
+        return privateKey;
+    }
+
+    @Override
+    public String chooseClientAlias(String[] keyTypes, Principal[] issuers, Socket socket) {
+        return chooseAlias(keyTypes, issuers);
+    }
+
+    @Override
+    public X509Certificate[] getCertificateChain(String alias) {
+        return (mAlias.equals(alias) ? mChain : null);
+    }
+
+    @Override
+    public PrivateKey getPrivateKey(String alias) {
+        return (mAlias.equals(alias) ? mPrivateKey : null);
+    }
+
+    @Override
+    public String chooseServerAlias(String keyType, Principal[] issuers, Socket socket) {
+        return chooseAlias(new String[] { keyType }, issuers);
+    }
+
+    @Override
+    public String[] getClientAliases(String keyType, Principal[] issuers) {
+        final String al = chooseAlias(new String[] { keyType }, issuers);
+        return (al == null ? null : new String[] { al });
+    }
+
+    @Override
+    public String[] getServerAliases(String keyType, Principal[] issuers) {
+        final String al = chooseAlias(new String[] { keyType }, issuers);
+        return (al == null ? null : new String[] { al });
+    }
+
+    @Override
+    public String chooseEngineClientAlias(String[] keyTypes, Principal[] issuers, SSLEngine engine) {
+        return chooseAlias(keyTypes, issuers);
+    }
+
+    @Override
+    public String chooseEngineServerAlias(String keyType, Principal[] issuers, SSLEngine engine) {
+        return chooseAlias(new String[] { keyType }, issuers);
+    }
+
+    private String chooseAlias(String[] keyTypes, Principal[] issuers) {
+        if (keyTypes == null || keyTypes.length == 0) {
+            return null;
+        }
+        final X509Certificate cert = mChain[0];
+        final String certKeyAlg = cert.getPublicKey().getAlgorithm();
+        final String certSigAlg = cert.getSigAlgName().toUpperCase(Locale.US);
+        for (String keyAlgorithm : keyTypes) {
+            if (keyAlgorithm == null) {
+                continue;
+            }
+            final String sigAlgorithm;
+            // handle cases like EC_EC and EC_RSA
+            int index = keyAlgorithm.indexOf('_');
+            if (index == -1) {
+                sigAlgorithm = null;
+            } else {
+                sigAlgorithm = keyAlgorithm.substring(index + 1);
+                keyAlgorithm = keyAlgorithm.substring(0, index);
+            }
+            // key algorithm does not match
+            if (!certKeyAlg.equals(keyAlgorithm)) {
+                continue;
+            }
+            /*
+             * TODO find a more reliable test for signature
+             * algorithm. Unfortunately value varies with
+             * provider. For example for "EC" it could be
+             * "SHA1WithECDSA" or simply "ECDSA".
+             */
+            // sig algorithm does not match
+            if (sigAlgorithm != null && certSigAlg != null
+                    && !certSigAlg.contains(sigAlgorithm)) {
+                continue;
+            }
+            // no issuers to match
+            if (issuers == null || issuers.length == 0) {
+                return mAlias;
+            }
+            List<Principal> issuersList = Arrays.asList(issuers);
+            // check that a certificate in the chain was issued by one of the specified issuers
+            for (X509Certificate certFromChain : mChain) {
+                /*
+                 * Note use of X500Principal from
+                 * getIssuerX500Principal as opposed to Principal
+                 * from getIssuerDN. Principal.equals test does
+                 * not work in the case where
+                 * xcertFromChain.getIssuerDN is a bouncycastle
+                 * org.bouncycastle.jce.X509Principal.
+                 */
+                X500Principal issuerFromChain = certFromChain.getIssuerX500Principal();
+                if (issuersList.contains(issuerFromChain)) {
+                    return mAlias;
+                }
+            }
+            Timber.w("Client certificate %s not issued by any of the requested issuers", mAlias);
+            return null;
+        }
+        Timber.w("Client certificate %s does not match any of the requested key types", mAlias);
+        return null;
+    }
+}
diff --git a/app-feature-preview/src/main/java/app/k9mail/feature/preview/navigation/FeatureNavHost.kt b/app-feature-preview/src/main/java/app/k9mail/feature/preview/navigation/FeatureNavHost.kt
index b0c7c03709bdd0f7004660fbda4067ce12434620..d25543864c79b96376fbc5654df9e20f43ce18c4 100644
--- a/app-feature-preview/src/main/java/app/k9mail/feature/preview/navigation/FeatureNavHost.kt
+++ b/app-feature-preview/src/main/java/app/k9mail/feature/preview/navigation/FeatureNavHost.kt
@@ -4,10 +4,11 @@ import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.navigation.NavHostController
 import androidx.navigation.compose.NavHost
-import app.k9mail.feature.account.setup.navigation.accountSetupScreen
+import app.k9mail.feature.account.setup.navigation.accountSetupRoute
 import app.k9mail.feature.account.setup.navigation.navigateToAccountSetup
 import app.k9mail.feature.onboarding.navigation.NAVIGATION_ROUTE_ONBOARDING
-import app.k9mail.feature.onboarding.navigation.onboardingScreen
+import app.k9mail.feature.onboarding.navigation.navigateToOnboarding
+import app.k9mail.feature.onboarding.navigation.onboardingRoute
 
 @Composable
 fun FeatureNavHost(
@@ -20,13 +21,13 @@ fun FeatureNavHost(
         startDestination = startDestination,
         modifier = modifier,
     ) {
-        onboardingScreen(
-            onStartClick = { navController.navigateToAccountSetup() },
-            onImportClick = { /* TODO */ },
+        onboardingRoute(
+            onStart = { navController.navigateToAccountSetup() },
+            onImport = { /* TODO */ },
         )
-        accountSetupScreen(
-            onBackClick = navController::popBackStack,
-            onFinishClick = { /* TODO */ },
+        accountSetupRoute(
+            onBack = navController::popBackStack,
+            onFinish = { navController.navigateToOnboarding() },
         )
     }
 }
diff --git a/app-feature-preview/src/main/java/app/k9mail/feature/preview/ui/FeatureApp.kt b/app-feature-preview/src/main/java/app/k9mail/feature/preview/ui/FeatureApp.kt
index baa3ceddb80a8938d2d3c6f558cddbd0e1bc052c..1d6c0bd801065001143ee73d1e418218dbf6d2a0 100644
--- a/app-feature-preview/src/main/java/app/k9mail/feature/preview/ui/FeatureApp.kt
+++ b/app-feature-preview/src/main/java/app/k9mail/feature/preview/ui/FeatureApp.kt
@@ -1,10 +1,7 @@
 package app.k9mail.feature.preview.ui
 
-import androidx.compose.foundation.layout.WindowInsets
-import androidx.compose.foundation.layout.asPaddingValues
 import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.systemBars
+import androidx.compose.foundation.layout.safeDrawingPadding
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.navigation.compose.rememberNavController
@@ -19,12 +16,10 @@ fun FeatureApp(
     val navController = rememberNavController()
 
     K9Theme {
-        val contentPadding = WindowInsets.systemBars.asPaddingValues()
-
         Background(
             modifier = Modifier
                 .fillMaxSize()
-                .padding(contentPadding)
+                .safeDrawingPadding()
                 .then(modifier),
         ) {
             FeatureNavHost(navController = navController)
diff --git a/app-feature-preview/src/main/res/values/colors.xml b/app-feature-preview/src/main/res/values/colors.xml
index 184131ea98b77859b530e987f470c1da6e516d08..41c8df6bf05ad3a055b01ec4af5851783dd05cf3 100644
--- a/app-feature-preview/src/main/res/values/colors.xml
+++ b/app-feature-preview/src/main/res/values/colors.xml
@@ -1,9 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
-    <!--  Material green 300  -->
-    <color name="ic_launcher_logo_main">#81C784</color>
-    <!--  Material green 700  -->
-    <color name="ic_launcher_logo_shadow">#FF388E3C</color>
     <!--  Material green 50  -->
     <color name="ic_launcher_background">#FFFF7300</color>
 </resources>
diff --git a/app-feature-preview/src/main/res/values/themes.xml b/app-feature-preview/src/main/res/values/themes.xml
index 5bfdb913ac697a755a7c0ebd6608b5b006c53330..b784534a72714ddc8861f4cbd13ade270e46671d 100644
--- a/app-feature-preview/src/main/res/values/themes.xml
+++ b/app-feature-preview/src/main/res/values/themes.xml
@@ -1,6 +1,9 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
-    <style name="Theme.Thunderbird" parent="Theme.MaterialComponents.DayNight.NoActionBar" />
+    <style name="Theme.Thunderbird" parent="Theme.MaterialComponents.DayNight.NoActionBar">
+        <item name="android:statusBarColor">@android:color/transparent</item>
+        <item name="android:navigationBarColor">@android:color/transparent</item>
+    </style>
 
     <style name="Theme.Thunderbird.Splashscreen" parent="Theme.SplashScreen">
         <item name="windowSplashScreenAnimatedIcon">@drawable/ic_launcher_foreground</item>
diff --git a/app-feature-preview/src/main/res/xml/network_security_config.xml b/app-feature-preview/src/main/res/xml/network_security_config.xml
new file mode 100644
index 0000000000000000000000000000000000000000..094d43225127492bdcb2444b0c828a628d332cb8
--- /dev/null
+++ b/app-feature-preview/src/main/res/xml/network_security_config.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<network-security-config xmlns:tools="http://schemas.android.com/tools"
+    tools:ignore="InsecureBaseConfiguration,AcceptsUserCertificates">
+
+    <base-config cleartextTrafficPermitted="true">
+        <trust-anchors>
+            <certificates src="system" />
+            <certificates src="user" />
+        </trust-anchors>
+    </base-config>
+
+</network-security-config>
diff --git a/app-ui-catalog/build.gradle.kts b/app-ui-catalog/build.gradle.kts
index 97166e25954ec1291b30ab4c049b73e68088786c..2e2544b485463f4a548c213341828c11b0a520f6 100644
--- a/app-ui-catalog/build.gradle.kts
+++ b/app-ui-catalog/build.gradle.kts
@@ -14,4 +14,7 @@ android {
 
 dependencies {
     implementation(projects.core.ui.compose.designsystem)
+
+    implementation(libs.androidx.compose.material)
+    implementation(libs.androidx.compose.material.icons.extended)
 }
diff --git a/app-ui-catalog/src/main/AndroidManifest.xml b/app-ui-catalog/src/main/AndroidManifest.xml
index f39530bf044b654659c5dfbca4397e1c87c0310e..a8179f1005aaada3c9d5155e04648695c6a5a6df 100644
--- a/app-ui-catalog/src/main/AndroidManifest.xml
+++ b/app-ui-catalog/src/main/AndroidManifest.xml
@@ -2,6 +2,7 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
 
     <application
+        android:name=".CatalogApplication"
         android:allowBackup="true"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
@@ -11,14 +12,16 @@
 
         <activity
             android:name=".CatalogActivity"
-            android:exported="true">
+            android:exported="true"
+            android:windowSoftInputMode="adjustResize"
+            >
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
 
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
         </activity>
-        
+
     </application>
 
 </manifest>
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogActivity.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogActivity.kt
index f2c3b0ffe8a354764e3ce2778e9de298aefdb740..799e9c7d1158146538819310905c05d23cf2dbda 100644
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogActivity.kt
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogActivity.kt
@@ -2,9 +2,10 @@ package app.k9mail.ui.catalog
 
 import android.os.Bundle
 import androidx.activity.ComponentActivity
-import androidx.activity.compose.setContent
 import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
 import androidx.core.view.WindowCompat
+import app.k9mail.core.ui.compose.common.activity.setActivityContent
+import app.k9mail.ui.catalog.ui.CatalogScreen
 
 class CatalogActivity : ComponentActivity() {
     override fun onCreate(savedInstanceState: Bundle?) {
@@ -14,7 +15,7 @@ class CatalogActivity : ComponentActivity() {
 
         WindowCompat.setDecorFitsSystemWindows(window, false)
 
-        setContent {
+        setActivityContent {
             CatalogScreen()
         }
     }
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogApplication.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogApplication.kt
new file mode 100644
index 0000000000000000000000000000000000000000..f351adcbd83abf8d69be171aca9f0a3f1f553c66
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogApplication.kt
@@ -0,0 +1,18 @@
+package app.k9mail.ui.catalog
+
+import android.app.Application
+import app.k9mail.ui.catalog.ui.catalogUiModule
+import org.koin.android.ext.koin.androidContext
+import org.koin.core.context.startKoin
+
+class CatalogApplication : Application() {
+
+    override fun onCreate() {
+        super.onCreate()
+
+        startKoin {
+            androidContext(this@CatalogApplication)
+            modules(catalogUiModule)
+        }
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogContent.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogContent.kt
deleted file mode 100644
index 19e4ed24e73431141adfd0863e2819a924a00503..0000000000000000000000000000000000000000
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogContent.kt
+++ /dev/null
@@ -1,89 +0,0 @@
-package app.k9mail.ui.catalog
-
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.PaddingValues
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.lazy.grid.GridCells
-import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.unit.dp
-import app.k9mail.core.ui.compose.common.DevicePreviews
-import app.k9mail.core.ui.compose.designsystem.atom.Surface
-import app.k9mail.core.ui.compose.designsystem.template.ResponsiveContent
-import app.k9mail.core.ui.compose.theme.K9Theme
-import app.k9mail.core.ui.compose.theme.MainTheme
-import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
-import app.k9mail.ui.catalog.items.buttonItems
-import app.k9mail.ui.catalog.items.colorItems
-import app.k9mail.ui.catalog.items.imageItems
-import app.k9mail.ui.catalog.items.selectionControlItems
-import app.k9mail.ui.catalog.items.textFieldItems
-import app.k9mail.ui.catalog.items.themeHeaderItem
-import app.k9mail.ui.catalog.items.themeSelectorItems
-import app.k9mail.ui.catalog.items.typographyItems
-
-@Composable
-fun CatalogContent(
-    catalogTheme: CatalogTheme,
-    catalogThemeVariant: CatalogThemeVariant,
-    onThemeChange: () -> Unit,
-    onThemeVariantChange: () -> Unit,
-    contentPadding: PaddingValues,
-    modifier: Modifier = Modifier,
-) {
-    Surface {
-        ResponsiveContent {
-            LazyVerticalGrid(
-                columns = GridCells.Adaptive(300.dp),
-                contentPadding = contentPadding,
-                horizontalArrangement = Arrangement.spacedBy(MainTheme.spacings.double),
-                verticalArrangement = Arrangement.spacedBy(MainTheme.spacings.double),
-                modifier = modifier.padding(MainTheme.spacings.double),
-            ) {
-                themeHeaderItem(text = "Thunderbird Catalog")
-                themeSelectorItems(
-                    catalogTheme = catalogTheme,
-                    catalogThemeVariant = catalogThemeVariant,
-                    onThemeChange = onThemeChange,
-                    onThemeVariantChange = onThemeVariantChange,
-                )
-
-                typographyItems()
-                colorItems()
-                buttonItems()
-                selectionControlItems()
-                textFieldItems()
-                imageItems()
-            }
-        }
-    }
-}
-
-@DevicePreviews
-@Composable
-internal fun CatalogContentK9ThemePreview() {
-    K9Theme {
-        CatalogContent(
-            catalogTheme = CatalogTheme.K9,
-            catalogThemeVariant = CatalogThemeVariant.LIGHT,
-            onThemeChange = {},
-            onThemeVariantChange = {},
-            contentPadding = PaddingValues(),
-        )
-    }
-}
-
-@DevicePreviews
-@Composable
-internal fun CatalogContentThunderbirdThemePreview() {
-    ThunderbirdTheme {
-        CatalogContent(
-            catalogTheme = CatalogTheme.THUNDERBIRD,
-            catalogThemeVariant = CatalogThemeVariant.LIGHT,
-            onThemeChange = {},
-            onThemeVariantChange = {},
-            contentPadding = PaddingValues(),
-        )
-    }
-}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogScreen.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogScreen.kt
deleted file mode 100644
index f7b03e55471dc80697be1ec046fd3394d4cebb99..0000000000000000000000000000000000000000
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogScreen.kt
+++ /dev/null
@@ -1,53 +0,0 @@
-package app.k9mail.ui.catalog
-
-import androidx.compose.foundation.layout.WindowInsets
-import androidx.compose.foundation.layout.asPaddingValues
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.systemBars
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Modifier
-import app.k9mail.core.ui.compose.common.DevicePreviews
-
-@Composable
-fun CatalogScreen(
-    modifier: Modifier = Modifier,
-) {
-    val themeState = remember { mutableStateOf(CatalogTheme.K9) }
-    val themeVariantState = remember { mutableStateOf(CatalogThemeVariant.LIGHT) }
-
-    CatalogThemeSwitch(
-        theme = themeState.value,
-        themeVariant = themeVariantState.value,
-    ) {
-        val contentPadding = WindowInsets.systemBars.asPaddingValues()
-
-        CatalogContent(
-            catalogTheme = themeState.value,
-            catalogThemeVariant = themeVariantState.value,
-            onThemeChange = {
-                themeState.value = when (themeState.value) {
-                    CatalogTheme.K9 -> CatalogTheme.THUNDERBIRD
-                    CatalogTheme.THUNDERBIRD -> CatalogTheme.K9
-                }
-            },
-            onThemeVariantChange = {
-                themeVariantState.value = when (themeVariantState.value) {
-                    CatalogThemeVariant.LIGHT -> CatalogThemeVariant.DARK
-                    CatalogThemeVariant.DARK -> CatalogThemeVariant.LIGHT
-                }
-            },
-            contentPadding = contentPadding,
-            modifier = Modifier
-                .fillMaxSize()
-                .then(modifier),
-        )
-    }
-}
-
-@DevicePreviews
-@Composable
-internal fun CatalogScreenPreview() {
-    CatalogScreen()
-}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogTheme.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogTheme.kt
deleted file mode 100644
index 123dd4e1bb087d25d61d183488a90fce526b0555..0000000000000000000000000000000000000000
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogTheme.kt
+++ /dev/null
@@ -1,13 +0,0 @@
-package app.k9mail.ui.catalog
-
-enum class CatalogTheme(
-    private val displayName: String,
-) {
-    K9("K-9"),
-    THUNDERBIRD("Thunderbird"),
-    ;
-
-    override fun toString(): String {
-        return displayName
-    }
-}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogThemeVariant.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogThemeVariant.kt
deleted file mode 100644
index 0b8cee444e31dc970524cb66c8b73416327b1d60..0000000000000000000000000000000000000000
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogThemeVariant.kt
+++ /dev/null
@@ -1,5 +0,0 @@
-package app.k9mail.ui.catalog
-
-enum class CatalogThemeVariant {
-    LIGHT, DARK
-}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/ImageItems.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/ImageItems.kt
deleted file mode 100644
index e4ff3e9cafcabc2fbba4c569a8b74171a6244365..0000000000000000000000000000000000000000
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/ImageItems.kt
+++ /dev/null
@@ -1,13 +0,0 @@
-package app.k9mail.ui.catalog.items
-
-import androidx.compose.foundation.Image
-import androidx.compose.foundation.lazy.grid.LazyGridScope
-import androidx.compose.ui.res.painterResource
-import app.k9mail.core.ui.compose.theme.MainTheme
-
-fun LazyGridScope.imageItems() {
-    sectionHeaderItem(text = "Images")
-    item {
-        Image(painter = painterResource(id = MainTheme.images.logo), contentDescription = "logo")
-    }
-}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/SectionHeaderItem.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/SectionHeaderItem.kt
deleted file mode 100644
index 7e144028fbacce9edc175a7cadaab1b7e2eda035..0000000000000000000000000000000000000000
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/SectionHeaderItem.kt
+++ /dev/null
@@ -1,16 +0,0 @@
-package app.k9mail.ui.catalog.items
-
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.lazy.grid.GridItemSpan
-import androidx.compose.foundation.lazy.grid.LazyGridScope
-import androidx.compose.ui.Modifier
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline6
-import app.k9mail.core.ui.compose.theme.MainTheme
-
-fun LazyGridScope.sectionHeaderItem(
-    text: String,
-) {
-    item(span = { GridItemSpan(maxLineSpan) }) {
-        TextHeadline6(text = text, modifier = Modifier.padding(top = MainTheme.spacings.default))
-    }
-}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/SectionSubtitleItem.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/SectionSubtitleItem.kt
deleted file mode 100644
index 015466a11e2365f11a8bdbe93a040cb677314d10..0000000000000000000000000000000000000000
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/SectionSubtitleItem.kt
+++ /dev/null
@@ -1,16 +0,0 @@
-package app.k9mail.ui.catalog.items
-
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.lazy.grid.GridItemSpan
-import androidx.compose.foundation.lazy.grid.LazyGridScope
-import androidx.compose.ui.Modifier
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextSubtitle1
-import app.k9mail.core.ui.compose.theme.MainTheme
-
-fun LazyGridScope.sectionSubtitleItem(
-    text: String,
-) {
-    item(span = { GridItemSpan(maxLineSpan) }) {
-        TextSubtitle1(text = text, modifier = Modifier.padding(top = MainTheme.spacings.default))
-    }
-}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/TextFieldItems.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/TextFieldItems.kt
deleted file mode 100644
index 9bfdc5f5365deb8e656b2b73dd2a6375cd848822..0000000000000000000000000000000000000000
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/TextFieldItems.kt
+++ /dev/null
@@ -1,90 +0,0 @@
-package app.k9mail.ui.catalog.items
-
-import androidx.compose.foundation.lazy.grid.LazyGridScope
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.MutableState
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import app.k9mail.core.ui.compose.designsystem.atom.textfield.PasswordTextFieldOutlined
-import app.k9mail.core.ui.compose.designsystem.atom.textfield.TextFieldOutlined
-
-fun LazyGridScope.textFieldItems() {
-    sectionHeaderItem(text = "Text fields")
-    textFieldOutlinedItems()
-    passwordTextFieldOutlinedItems()
-}
-
-private fun LazyGridScope.textFieldOutlinedItems() {
-    sectionSubtitleItem(text = "Outlined")
-    item {
-        WithRememberedInput(text = "Initial text") { input ->
-            TextFieldOutlined(
-                value = input.value,
-                label = "Label",
-                onValueChange = { input.value = it },
-            )
-        }
-    }
-    item {
-        WithRememberedInput(text = "Input text with error") { input ->
-            TextFieldOutlined(
-                value = input.value,
-                label = "Label",
-                onValueChange = { input.value = it },
-                isError = true,
-            )
-        }
-    }
-    item {
-        WithRememberedInput(text = "Input text disabled") { input ->
-            TextFieldOutlined(
-                value = input.value,
-                label = "Label",
-                onValueChange = { input.value = it },
-                enabled = false,
-            )
-        }
-    }
-}
-
-private fun LazyGridScope.passwordTextFieldOutlinedItems() {
-    sectionSubtitleItem(text = "Password outlined")
-    item {
-        WithRememberedInput(text = "Input text") { input ->
-            PasswordTextFieldOutlined(
-                value = input.value,
-                label = "Label",
-                onValueChange = { input.value = it },
-            )
-        }
-    }
-    item {
-        WithRememberedInput(text = "Input text with error") { input ->
-            PasswordTextFieldOutlined(
-                value = input.value,
-                label = "Label",
-                onValueChange = { input.value = it },
-                isError = true,
-            )
-        }
-    }
-    item {
-        WithRememberedInput(text = "Input text disabled") { input ->
-            PasswordTextFieldOutlined(
-                value = input.value,
-                label = "Label",
-                onValueChange = { input.value = it },
-                enabled = false,
-            )
-        }
-    }
-}
-
-@Composable
-private fun WithRememberedInput(
-    text: String,
-    content: @Composable (text: MutableState<String>) -> Unit,
-) {
-    val inputText = remember { mutableStateOf(text) }
-    content(inputText)
-}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/ThemeHeaderItem.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/ThemeHeaderItem.kt
deleted file mode 100644
index 023b72e716e5a71d43cc38a8ee0dcb661bd794af..0000000000000000000000000000000000000000
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/ThemeHeaderItem.kt
+++ /dev/null
@@ -1,16 +0,0 @@
-package app.k9mail.ui.catalog.items
-
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.lazy.grid.GridItemSpan
-import androidx.compose.foundation.lazy.grid.LazyGridScope
-import androidx.compose.ui.Modifier
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline4
-import app.k9mail.core.ui.compose.theme.MainTheme
-
-fun LazyGridScope.themeHeaderItem(
-    text: String,
-) {
-    item(span = { GridItemSpan(maxLineSpan) }) {
-        TextHeadline4(text = text, modifier = Modifier.padding(top = MainTheme.spacings.default))
-    }
-}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/ThemeSelectorItems.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/ThemeSelectorItems.kt
deleted file mode 100644
index 38dc19a63aca8fef77290093b32981b967bcfeee..0000000000000000000000000000000000000000
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/ThemeSelectorItems.kt
+++ /dev/null
@@ -1,31 +0,0 @@
-package app.k9mail.ui.catalog.items
-
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.lazy.grid.LazyGridScope
-import androidx.compose.ui.Modifier
-import app.k9mail.ui.catalog.CatalogTheme
-import app.k9mail.ui.catalog.CatalogThemeSelector
-import app.k9mail.ui.catalog.CatalogThemeVariant
-import app.k9mail.ui.catalog.CatalogThemeVariantSelector
-
-fun LazyGridScope.themeSelectorItems(
-    catalogTheme: CatalogTheme,
-    catalogThemeVariant: CatalogThemeVariant,
-    onThemeChange: () -> Unit,
-    onThemeVariantChange: () -> Unit,
-) {
-    item {
-        CatalogThemeSelector(
-            catalogTheme = catalogTheme,
-            modifier = Modifier.fillMaxWidth(),
-            onThemeChangeClick = onThemeChange,
-        )
-    }
-    item {
-        CatalogThemeVariantSelector(
-            catalogThemeVariant = catalogThemeVariant,
-            modifier = Modifier.fillMaxWidth(),
-            onThemeVariantChange = onThemeVariantChange,
-        )
-    }
-}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/TypographyItems.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/TypographyItems.kt
deleted file mode 100644
index 7ad1735d4704818e43233a0d229eb25eba07cdae..0000000000000000000000000000000000000000
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/TypographyItems.kt
+++ /dev/null
@@ -1,33 +0,0 @@
-package app.k9mail.ui.catalog.items
-
-import androidx.compose.foundation.lazy.grid.LazyGridScope
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextBody1
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextBody2
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextButton
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextCaption
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline1
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline2
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline3
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline4
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline5
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline6
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextOverline
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextSubtitle1
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextSubtitle2
-
-fun LazyGridScope.typographyItems() {
-    sectionHeaderItem(text = "Typography")
-    item { TextHeadline1(text = "Headline1") }
-    item { TextHeadline2(text = "Headline2") }
-    item { TextHeadline3(text = "Headline3") }
-    item { TextHeadline4(text = "Headline4") }
-    item { TextHeadline5(text = "Headline5") }
-    item { TextHeadline6(text = "Headline6") }
-    item { TextSubtitle1(text = "Subtitle1") }
-    item { TextSubtitle2(text = "Subtitle2") }
-    item { TextBody1(text = "Body1") }
-    item { TextBody2(text = "Body2") }
-    item { TextButton(text = "Button") }
-    item { TextCaption(text = "Caption") }
-    item { TextOverline(text = "Overline") }
-}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/CatalogContent.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/CatalogContent.kt
new file mode 100644
index 0000000000000000000000000000000000000000..0a96342d582b53c273f0b5ce333098c41a6e9d95
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/CatalogContent.kt
@@ -0,0 +1,58 @@
+package app.k9mail.ui.catalog.ui
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.navigation.compose.rememberNavController
+import app.k9mail.core.ui.compose.designsystem.template.Scaffold
+import app.k9mail.ui.catalog.ui.CatalogContract.State
+import app.k9mail.ui.catalog.ui.atom.navigateToCatalogAtom
+import app.k9mail.ui.catalog.ui.common.ThemeTopAppBar
+import app.k9mail.ui.catalog.ui.common.drawer.DrawerContent
+import app.k9mail.ui.catalog.ui.molecule.navigateToCatalogMolecule
+import app.k9mail.ui.catalog.ui.navigation.CatalogNavHost
+import app.k9mail.ui.catalog.ui.organism.navigateToCatalogOrganism
+
+@Composable
+fun CatalogContent(
+    state: State,
+    onThemeChanged: () -> Unit,
+    onThemeVariantChanged: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val navController = rememberNavController()
+
+    Scaffold(
+        modifier = modifier,
+        topBar = { toggleDrawer ->
+            ThemeTopAppBar(
+                onNavigationClick = toggleDrawer,
+                theme = state.theme,
+                themeVariant = state.themeVariant,
+                onThemeClick = onThemeChanged,
+                onThemeVariantClick = onThemeVariantChanged,
+            )
+        },
+        drawerContent = { toogleDrawer ->
+            DrawerContent(
+                toggleDrawer = toogleDrawer,
+                theme = state.theme,
+                themeVariant = state.themeVariant,
+                onThemeChanged = onThemeChanged,
+                onThemeVariantChanged = onThemeVariantChanged,
+                onNavigateToAtoms = {
+                    navController.navigateToCatalogAtom()
+                },
+                onNavigateToMolecules = {
+                    navController.navigateToCatalogMolecule()
+                },
+                onNavigateToOrganisms = {
+                    navController.navigateToCatalogOrganism()
+                },
+            )
+        },
+    ) {
+        CatalogNavHost(
+            navController = navController,
+        )
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/CatalogContract.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/CatalogContract.kt
new file mode 100644
index 0000000000000000000000000000000000000000..2d52d435146d2368c2e00afa7595b9614c531d92
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/CatalogContract.kt
@@ -0,0 +1,33 @@
+package app.k9mail.ui.catalog.ui
+
+import app.k9mail.core.ui.compose.common.mvi.UnidirectionalViewModel
+
+interface CatalogContract {
+
+    enum class Theme(
+        val displayName: String,
+    ) {
+        K9("K-9"),
+        THUNDERBIRD("Thunderbird"),
+    }
+
+    enum class ThemeVariant(
+        val displayName: String,
+    ) {
+        LIGHT("Light"),
+        DARK("Dark"),
+    }
+
+    interface ViewModel : UnidirectionalViewModel<State, Event, Nothing>
+
+    data class State(
+        val theme: Theme = Theme.K9,
+        val themeVariant: ThemeVariant = ThemeVariant.LIGHT,
+    )
+
+    sealed interface Event {
+        object OnThemeChanged : Event
+
+        object OnThemeVariantChanged : Event
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/CatalogScreen.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/CatalogScreen.kt
new file mode 100644
index 0000000000000000000000000000000000000000..813c2bc09b44840d723627fb471412e03d9dafdd
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/CatalogScreen.kt
@@ -0,0 +1,39 @@
+package app.k9mail.ui.catalog.ui
+
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.safeDrawingPadding
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import app.k9mail.core.ui.compose.common.mvi.observe
+import app.k9mail.core.ui.compose.designsystem.atom.Background
+import app.k9mail.ui.catalog.ui.CatalogContract.Event.OnThemeChanged
+import app.k9mail.ui.catalog.ui.CatalogContract.Event.OnThemeVariantChanged
+import app.k9mail.ui.catalog.ui.CatalogContract.ViewModel
+import app.k9mail.ui.catalog.ui.common.theme.ThemeSwitch
+import org.koin.androidx.compose.koinViewModel
+
+@Composable
+fun CatalogScreen(
+    modifier: Modifier = Modifier,
+    viewModel: ViewModel = koinViewModel<CatalogViewModel>(),
+) {
+    val (state, dispatch) = viewModel.observe(handleEffect = {})
+
+    ThemeSwitch(
+        theme = state.value.theme,
+        themeVariant = state.value.themeVariant,
+    ) {
+        Background(
+            modifier = Modifier
+                .fillMaxSize()
+                .safeDrawingPadding()
+                .then(modifier),
+        ) {
+            CatalogContent(
+                state = state.value,
+                onThemeChanged = { dispatch(OnThemeChanged) },
+                onThemeVariantChanged = { dispatch(OnThemeVariantChanged) },
+            )
+        }
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/CatalogUiModule.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/CatalogUiModule.kt
new file mode 100644
index 0000000000000000000000000000000000000000..1df4100127bff76a2ab3cc7fdb02cd53c980cc82
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/CatalogUiModule.kt
@@ -0,0 +1,9 @@
+package app.k9mail.ui.catalog.ui
+
+import org.koin.androidx.viewmodel.dsl.viewModel
+import org.koin.core.module.Module
+import org.koin.dsl.module
+
+val catalogUiModule: Module = module {
+    viewModel { CatalogViewModel() }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/CatalogViewModel.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/CatalogViewModel.kt
new file mode 100644
index 0000000000000000000000000000000000000000..1f528198d8901a87712e3a07476cca34af5f6158
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/CatalogViewModel.kt
@@ -0,0 +1,34 @@
+package app.k9mail.ui.catalog.ui
+
+import app.k9mail.core.ui.compose.common.mvi.BaseViewModel
+import app.k9mail.ui.catalog.ui.CatalogContract.Event
+import app.k9mail.ui.catalog.ui.CatalogContract.Event.OnThemeChanged
+import app.k9mail.ui.catalog.ui.CatalogContract.Event.OnThemeVariantChanged
+import app.k9mail.ui.catalog.ui.CatalogContract.State
+import app.k9mail.ui.catalog.ui.CatalogContract.Theme.K9
+import app.k9mail.ui.catalog.ui.CatalogContract.Theme.THUNDERBIRD
+import app.k9mail.ui.catalog.ui.CatalogContract.ThemeVariant.DARK
+import app.k9mail.ui.catalog.ui.CatalogContract.ThemeVariant.LIGHT
+import app.k9mail.ui.catalog.ui.CatalogContract.ViewModel
+
+class CatalogViewModel(
+    initialState: State = State(),
+) : BaseViewModel<State, Event, Nothing>(initialState), ViewModel {
+    override fun event(event: Event) {
+        when (event) {
+            is OnThemeChanged -> {
+                when (state.value.theme) {
+                    K9 -> updateState { it.copy(theme = THUNDERBIRD) }
+                    THUNDERBIRD -> updateState { it.copy(theme = K9) }
+                }
+            }
+
+            is OnThemeVariantChanged -> {
+                when (state.value.themeVariant) {
+                    LIGHT -> updateState { it.copy(themeVariant = DARK) }
+                    DARK -> updateState { it.copy(themeVariant = LIGHT) }
+                }
+            }
+        }
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/CatalogAtomContent.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/CatalogAtomContent.kt
new file mode 100644
index 0000000000000000000000000000000000000000..537c14af6b2785846ec5648b280d89ab83901820
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/CatalogAtomContent.kt
@@ -0,0 +1,69 @@
+package app.k9mail.ui.catalog.ui.atom
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import app.k9mail.core.ui.compose.common.DevicePreviews
+import app.k9mail.core.ui.compose.theme.K9Theme
+import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
+import app.k9mail.ui.catalog.ui.atom.CatalogAtomPage.BUTTON
+import app.k9mail.ui.catalog.ui.atom.CatalogAtomPage.COLOR
+import app.k9mail.ui.catalog.ui.atom.CatalogAtomPage.ICON
+import app.k9mail.ui.catalog.ui.atom.CatalogAtomPage.IMAGE
+import app.k9mail.ui.catalog.ui.atom.CatalogAtomPage.SELECTION_CONTROL
+import app.k9mail.ui.catalog.ui.atom.CatalogAtomPage.TEXT_FIELD
+import app.k9mail.ui.catalog.ui.atom.CatalogAtomPage.TYPOGRAPHY
+import app.k9mail.ui.catalog.ui.atom.items.buttonItems
+import app.k9mail.ui.catalog.ui.atom.items.colorItems
+import app.k9mail.ui.catalog.ui.atom.items.iconItems
+import app.k9mail.ui.catalog.ui.atom.items.imageItems
+import app.k9mail.ui.catalog.ui.atom.items.selectionControlItems
+import app.k9mail.ui.catalog.ui.atom.items.textFieldItems
+import app.k9mail.ui.catalog.ui.atom.items.typographyItems
+import app.k9mail.ui.catalog.ui.common.PagedContent
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.persistentListOf
+
+@Composable
+fun CatalogContent(
+    pages: ImmutableList<CatalogAtomPage>,
+    initialPage: CatalogAtomPage,
+    modifier: Modifier = Modifier,
+) {
+    PagedContent(
+        pages = pages,
+        initialPage = initialPage,
+        modifier = modifier,
+    ) {
+        when (it) {
+            TYPOGRAPHY -> typographyItems()
+            COLOR -> colorItems()
+            BUTTON -> buttonItems()
+            SELECTION_CONTROL -> selectionControlItems()
+            TEXT_FIELD -> textFieldItems()
+            ICON -> iconItems()
+            IMAGE -> imageItems()
+        }
+    }
+}
+
+@DevicePreviews
+@Composable
+internal fun CatalogContentK9ThemePreview() {
+    K9Theme {
+        CatalogContent(
+            pages = persistentListOf(TYPOGRAPHY, COLOR),
+            initialPage = TYPOGRAPHY,
+        )
+    }
+}
+
+@DevicePreviews
+@Composable
+internal fun CatalogContentThunderbirdThemePreview() {
+    ThunderbirdTheme {
+        CatalogContent(
+            pages = persistentListOf(TYPOGRAPHY, COLOR),
+            initialPage = TYPOGRAPHY,
+        )
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/CatalogAtomNavigation.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/CatalogAtomNavigation.kt
new file mode 100644
index 0000000000000000000000000000000000000000..18607d492c9882dc54ed81e842a984acbfd98ad5
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/CatalogAtomNavigation.kt
@@ -0,0 +1,23 @@
+package app.k9mail.ui.catalog.ui.atom
+
+import androidx.navigation.NavController
+import androidx.navigation.NavGraphBuilder
+import androidx.navigation.NavOptions
+import androidx.navigation.compose.composable
+
+const val NAVIGATION_ROUTE_CATALOG_ATOM = "/catalog/atom"
+
+fun NavController.navigateToCatalogAtom() {
+    navigate(
+        route = NAVIGATION_ROUTE_CATALOG_ATOM,
+        navOptions = NavOptions.Builder()
+            .setLaunchSingleTop(true)
+            .build(),
+    )
+}
+
+fun NavGraphBuilder.catalogAtomRoute() {
+    composable(route = NAVIGATION_ROUTE_CATALOG_ATOM) {
+        CatalogAtomScreen()
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/CatalogAtomPage.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/CatalogAtomPage.kt
new file mode 100644
index 0000000000000000000000000000000000000000..1eae2e27c5e31c930f0eac481a2112230b1ad011
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/CatalogAtomPage.kt
@@ -0,0 +1,24 @@
+package app.k9mail.ui.catalog.ui.atom
+
+import kotlinx.collections.immutable.toImmutableList
+
+enum class CatalogAtomPage(
+    private val displayName: String,
+) {
+    TYPOGRAPHY("Typography"),
+    COLOR("Colors"),
+    BUTTON("Buttons"),
+    SELECTION_CONTROL("Selection Controls"),
+    TEXT_FIELD("TextFields"),
+    ICON("Icons"),
+    IMAGE("Images"),
+    ;
+
+    override fun toString(): String {
+        return displayName
+    }
+
+    companion object {
+        fun all() = values().toList().toImmutableList()
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/CatalogAtomScreen.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/CatalogAtomScreen.kt
new file mode 100644
index 0000000000000000000000000000000000000000..ddf7c54e5ca3dc2be1e0437c10cad7d3218965c0
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/CatalogAtomScreen.kt
@@ -0,0 +1,15 @@
+package app.k9mail.ui.catalog.ui.atom
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+
+@Composable
+fun CatalogAtomScreen(
+    modifier: Modifier = Modifier,
+) {
+    CatalogContent(
+        pages = CatalogAtomPage.all(),
+        initialPage = CatalogAtomPage.TYPOGRAPHY,
+        modifier = modifier,
+    )
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/ButtonItems.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/ButtonItems.kt
similarity index 54%
rename from app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/ButtonItems.kt
rename to app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/ButtonItems.kt
index c2f03df1467a1ea7656699b3ce98607b41b6f542..31fda531418de673d26963b1ec25bdbfc5372abc 100644
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/ButtonItems.kt
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/ButtonItems.kt
@@ -1,39 +1,50 @@
-package app.k9mail.ui.catalog.items
+package app.k9mail.ui.catalog.ui.atom.items
 
 import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.FlowRow
 import androidx.compose.foundation.lazy.grid.LazyGridScope
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
 import app.k9mail.core.ui.compose.designsystem.atom.button.Button
 import app.k9mail.core.ui.compose.designsystem.atom.button.ButtonOutlined
 import app.k9mail.core.ui.compose.designsystem.atom.button.ButtonText
 import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.ui.catalog.ui.common.list.itemDefaultPadding
+import app.k9mail.ui.catalog.ui.common.list.sectionHeaderItem
 
+@OptIn(ExperimentalLayoutApi::class)
 fun LazyGridScope.buttonItems() {
-    sectionHeaderItem(text = "Buttons")
-    sectionSubtitleItem(text = "Contained")
+    sectionHeaderItem(text = "Buttons - Filled")
     item {
-        Row(
+        FlowRow(
             horizontalArrangement = Arrangement.spacedBy(MainTheme.spacings.default),
+            modifier = Modifier.itemDefaultPadding(),
         ) {
             Button(text = "Enabled", onClick = { })
+            Button(text = "Colored", onClick = { }, color = Color.Magenta)
             Button(text = "Disabled", onClick = { }, enabled = false)
         }
     }
-    sectionSubtitleItem(text = "Outlined")
+    sectionHeaderItem(text = "Buttons - Outlined")
     item {
-        Row(
+        FlowRow(
             horizontalArrangement = Arrangement.spacedBy(MainTheme.spacings.default),
+            modifier = Modifier.itemDefaultPadding(),
         ) {
             ButtonOutlined(text = "Enabled", onClick = { })
+            ButtonOutlined(text = "Colored", onClick = { }, color = Color.Magenta)
             ButtonOutlined(text = "Disabled", onClick = { }, enabled = false)
         }
     }
-    sectionSubtitleItem(text = "Text")
+    sectionHeaderItem(text = "Buttons - Text only")
     item {
-        Row(
+        FlowRow(
             horizontalArrangement = Arrangement.spacedBy(MainTheme.spacings.default),
+            modifier = Modifier.itemDefaultPadding(),
         ) {
             ButtonText(text = "Enabled", onClick = { })
+            ButtonText(text = "Colored", onClick = { }, color = Color.Magenta)
             ButtonText(text = "Disabled", onClick = { }, enabled = false)
         }
     }
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/ColorItems.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/ColorItems.kt
similarity index 83%
rename from app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/ColorItems.kt
rename to app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/ColorItems.kt
index 34a49ce333d0fc9637843d84a144e4c0d2645a96..5a442ffae789d76bf187ee8bfca6f23a8e0ee079 100644
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/ColorItems.kt
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/ColorItems.kt
@@ -1,4 +1,4 @@
-package app.k9mail.ui.catalog.items
+package app.k9mail.ui.catalog.ui.atom.items
 
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Row
@@ -11,9 +11,11 @@ import androidx.compose.ui.graphics.Color
 import app.k9mail.core.ui.compose.designsystem.atom.Surface
 import app.k9mail.core.ui.compose.designsystem.atom.text.TextBody1
 import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.ui.catalog.ui.common.list.itemDefaultPadding
+import app.k9mail.ui.catalog.ui.common.list.sectionHeaderItem
 
 fun LazyGridScope.colorItems() {
-    sectionHeaderItem(text = "Colors")
+    sectionHeaderItem(text = "Material theme colors")
     item {
         ColorContent(
             name = "Primary",
@@ -66,11 +68,14 @@ private fun ColorContent(
 ) {
     Surface(
         color = color,
+        modifier = Modifier
+            .itemDefaultPadding()
+            .then(modifier),
     ) {
         Row(
             verticalAlignment = Alignment.CenterVertically,
             horizontalArrangement = Arrangement.Center,
-            modifier = modifier.padding(MainTheme.spacings.double),
+            modifier = Modifier.padding(MainTheme.spacings.double),
         ) {
             TextBody1(text = name)
         }
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/IconItems.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/IconItems.kt
new file mode 100644
index 0000000000000000000000000000000000000000..3938d185dca83395fed02e40c4aba610bfa7e1d3
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/IconItems.kt
@@ -0,0 +1,65 @@
+package app.k9mail.ui.catalog.ui.atom.items
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.lazy.grid.LazyGridScope
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.vector.ImageVector
+import app.k9mail.core.ui.compose.designsystem.atom.Icon
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextCaption
+import app.k9mail.core.ui.compose.theme.Icons
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.ui.catalog.ui.common.list.itemDefaultPadding
+import app.k9mail.ui.catalog.ui.common.list.sectionHeaderItem
+
+fun LazyGridScope.iconItems() {
+    sectionHeaderItem(text = "Filled")
+    getIconsFor(Icons.Filled)
+    sectionHeaderItem(text = "Outlined")
+    getIconsFor(Icons.Outlined)
+}
+
+private inline fun <reified T> LazyGridScope.getIconsFor(icons: T) {
+    for (field in T::class.java.declaredFields) {
+        if (field.name in exclusions) continue
+        item {
+            field.isAccessible = true
+            IconItem(
+                name = field.name.replaceFirstChar { it.uppercase() },
+                imageVector = field.get(icons) as ImageVector,
+            )
+        }
+    }
+}
+
+private val exclusions = listOf("\$stable", "INSTANCE")
+
+@Composable
+private fun IconItem(
+    name: String,
+    imageVector: ImageVector,
+    modifier: Modifier = Modifier,
+) {
+    Column(
+        modifier = Modifier
+            .itemDefaultPadding()
+            .then(modifier),
+        horizontalAlignment = Alignment.CenterHorizontally,
+        verticalArrangement = Arrangement.spacedBy(MainTheme.spacings.default),
+    ) {
+        Row {
+            Icon(
+                imageVector = imageVector,
+            )
+            Icon(
+                imageVector = imageVector,
+                tint = Color.Magenta,
+            )
+        }
+        TextCaption(text = name)
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/ImageItems.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/ImageItems.kt
new file mode 100644
index 0000000000000000000000000000000000000000..b3bae7d15565f5f73d1d925f1703310a9323b3a0
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/ImageItems.kt
@@ -0,0 +1,20 @@
+package app.k9mail.ui.catalog.ui.atom.items
+
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.lazy.grid.LazyGridScope
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.painterResource
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.ui.catalog.ui.common.list.itemDefaultPadding
+import app.k9mail.ui.catalog.ui.common.list.sectionHeaderItem
+
+fun LazyGridScope.imageItems() {
+    sectionHeaderItem(text = "Images")
+    item {
+        Image(
+            painter = painterResource(id = MainTheme.images.logo),
+            contentDescription = "logo",
+            modifier = Modifier.itemDefaultPadding(),
+        )
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/SelectionControlItems.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/SelectionControlItems.kt
similarity index 56%
rename from app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/SelectionControlItems.kt
rename to app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/SelectionControlItems.kt
index cd583cb9661dc15c723dfc9c5f2dd7b36f81ca8e..3633775ea23efb3ac5d86f0ecb0ae4964324c8ab 100644
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/items/SelectionControlItems.kt
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/SelectionControlItems.kt
@@ -1,15 +1,18 @@
-package app.k9mail.ui.catalog.items
+package app.k9mail.ui.catalog.ui.atom.items
 
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.lazy.grid.LazyGridScope
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
 import app.k9mail.core.ui.compose.designsystem.atom.Checkbox
+import app.k9mail.core.ui.compose.designsystem.atom.Switch
 import app.k9mail.core.ui.compose.designsystem.atom.text.TextCaption
+import app.k9mail.ui.catalog.ui.common.list.itemDefaultPadding
+import app.k9mail.ui.catalog.ui.common.list.sectionHeaderItem
 
 fun LazyGridScope.selectionControlItems() {
-    sectionHeaderItem(text = "Selection Controls")
-    sectionSubtitleItem(text = "Checkbox")
+    sectionHeaderItem(text = "Checkbox")
     captionItem(caption = "Checked") {
         Checkbox(checked = true, onCheckedChange = {})
     }
@@ -22,6 +25,19 @@ fun LazyGridScope.selectionControlItems() {
     captionItem(caption = "Disabled") {
         Checkbox(checked = false, onCheckedChange = {}, enabled = false)
     }
+    sectionHeaderItem(text = "Switch")
+    captionItem(caption = "Checked") {
+        Switch(checked = true, onCheckedChange = {})
+    }
+    captionItem(caption = "Unchecked") {
+        Switch(checked = false, onCheckedChange = {})
+    }
+    captionItem(caption = "Disabled Checked") {
+        Switch(checked = true, onCheckedChange = {}, enabled = false)
+    }
+    captionItem(caption = "Disabled") {
+        Switch(checked = false, onCheckedChange = {}, enabled = false)
+    }
 }
 
 private fun LazyGridScope.captionItem(
@@ -31,6 +47,7 @@ private fun LazyGridScope.captionItem(
     item {
         Column(
             horizontalAlignment = Alignment.CenterHorizontally,
+            modifier = Modifier.itemDefaultPadding(),
         ) {
             content()
             TextCaption(text = caption)
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/TextFieldItems.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/TextFieldItems.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c5196375315ea0a6369d76f54c83dcc0db28b488
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/TextFieldItems.kt
@@ -0,0 +1,275 @@
+package app.k9mail.ui.catalog.ui.atom.items
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.grid.LazyGridScope
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.Stable
+import androidx.compose.runtime.key
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import app.k9mail.core.ui.compose.designsystem.atom.Icon
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextSubtitle1
+import app.k9mail.core.ui.compose.designsystem.atom.textfield.TextFieldOutlined
+import app.k9mail.core.ui.compose.designsystem.atom.textfield.TextFieldOutlinedEmailAddress
+import app.k9mail.core.ui.compose.designsystem.atom.textfield.TextFieldOutlinedNumber
+import app.k9mail.core.ui.compose.designsystem.atom.textfield.TextFieldOutlinedPassword
+import app.k9mail.core.ui.compose.designsystem.atom.textfield.TextFieldOutlinedSelect
+import app.k9mail.core.ui.compose.designsystem.molecule.input.CheckboxInput
+import app.k9mail.core.ui.compose.theme.Icons
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.ui.catalog.ui.common.helper.WithRememberedState
+import app.k9mail.ui.catalog.ui.common.list.itemDefaultPadding
+import app.k9mail.ui.catalog.ui.common.list.sectionHeaderItem
+import app.k9mail.ui.catalog.ui.common.list.sectionSubtitleItem
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.persistentListOf
+
+fun LazyGridScope.textFieldItems() {
+    sectionHeaderItem(text = "Text field - Outlined")
+    sectionSubtitleItem(text = "Default")
+    textFieldOutlinedItems()
+    sectionSubtitleItem(text = "Password")
+    passwordTextFieldOutlinedItems()
+    sectionSubtitleItem(text = "Email address")
+    emailTextFieldOutlinedItems()
+    sectionSubtitleItem(text = "Number")
+    numberTextFieldOutlinedItems()
+    sectionSubtitleItem(text = "Selection")
+    selectionTextFieldOutlinedItems()
+}
+
+@Stable
+data class TextFieldState<T>(
+    val input: T,
+    val label: String = "Label",
+    val showLabel: Boolean = false,
+    val showTrailingIcon: Boolean = false,
+    val isDisabled: Boolean = false,
+    val isReadOnly: Boolean = false,
+    val isRequired: Boolean = false,
+    val hasError: Boolean = false,
+    val isSingleLine: Boolean = false,
+)
+
+@Suppress("LongMethod")
+@Composable
+fun <T> TextFieldDemo(
+    initialState: TextFieldState<T>,
+    modifier: Modifier = Modifier,
+    hasTrailingIcon: Boolean = false,
+    hasSingleLine: Boolean = false,
+    content: @Composable (state: MutableState<TextFieldState<T>>) -> Unit,
+) {
+    WithRememberedState(input = initialState) { state ->
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .itemDefaultPadding()
+                .then(modifier),
+        ) {
+            key(state.value.showLabel, state.value.isRequired) {
+                content(state)
+            }
+
+            Column(modifier = Modifier.fillMaxWidth()) {
+                Row(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(
+                            top = MainTheme.spacings.double,
+                            start = MainTheme.spacings.default,
+                        ),
+                ) {
+                    TextSubtitle1(text = "Configuration:")
+                }
+
+                CheckboxInput(
+                    text = "Show Label",
+                    checked = state.value.showLabel,
+                    onCheckedChange = { state.value = state.value.copy(showLabel = it) },
+                    contentPadding = defaultPadding,
+                )
+
+                if (hasTrailingIcon) {
+                    CheckboxInput(
+                        text = "Show Trailing Icon",
+                        checked = state.value.showTrailingIcon,
+                        onCheckedChange = { state.value = state.value.copy(showTrailingIcon = it) },
+                        contentPadding = defaultPadding,
+                    )
+                }
+
+                CheckboxInput(
+                    text = "Is required",
+                    checked = state.value.isRequired,
+                    onCheckedChange = { state.value = state.value.copy(isRequired = it) },
+                    contentPadding = defaultPadding,
+                )
+
+                CheckboxInput(
+                    text = "Is read-only",
+                    checked = state.value.isReadOnly,
+                    onCheckedChange = { state.value = state.value.copy(isReadOnly = it) },
+                    contentPadding = defaultPadding,
+                )
+
+                CheckboxInput(
+                    text = "Is disabled",
+                    checked = state.value.isDisabled,
+                    onCheckedChange = { state.value = state.value.copy(isDisabled = it) },
+                    contentPadding = defaultPadding,
+                )
+
+                CheckboxInput(
+                    text = "Has Error",
+                    checked = state.value.hasError,
+                    onCheckedChange = { state.value = state.value.copy(hasError = it) },
+                    contentPadding = defaultPadding,
+                )
+
+                if (hasSingleLine) {
+                    CheckboxInput(
+                        text = "Single line",
+                        checked = state.value.isSingleLine,
+                        onCheckedChange = { state.value = state.value.copy(isSingleLine = it) },
+                        contentPadding = defaultPadding,
+                    )
+                }
+            }
+        }
+    }
+}
+
+private val defaultPadding = PaddingValues(0.dp)
+
+private fun LazyGridScope.textFieldOutlinedItems() {
+    item {
+        TextFieldDemo(
+            hasTrailingIcon = true,
+            hasSingleLine = true,
+            initialState = TextFieldState(input = ""),
+        ) { state ->
+            TextFieldOutlined(
+                value = state.value.input,
+                label = if (state.value.showLabel) state.value.label else null,
+                onValueChange = { state.value = state.value.copy(input = it) },
+                trailingIcon = {
+                    if (state.value.showTrailingIcon) {
+                        Icon(imageVector = Icons.Filled.user)
+                    }
+                },
+                isEnabled = !state.value.isDisabled,
+                isReadOnly = state.value.isReadOnly,
+                isRequired = state.value.isRequired,
+                isSingleLine = state.value.isSingleLine,
+                hasError = state.value.hasError,
+                modifier = Modifier.fillMaxWidth(),
+            )
+        }
+    }
+}
+
+private fun LazyGridScope.passwordTextFieldOutlinedItems() {
+    item {
+        TextFieldDemo(
+            initialState = TextFieldState(
+                input = "",
+                label = "Password",
+            ),
+        ) { state ->
+            TextFieldOutlinedPassword(
+                value = state.value.input,
+                label = if (state.value.showLabel) state.value.label else null,
+                onValueChange = { state.value = state.value.copy(input = it) },
+                isEnabled = !state.value.isDisabled,
+                isReadOnly = state.value.isReadOnly,
+                isRequired = state.value.isRequired,
+                hasError = state.value.hasError,
+                modifier = Modifier.fillMaxWidth(),
+            )
+        }
+    }
+}
+
+private fun LazyGridScope.emailTextFieldOutlinedItems() {
+    item {
+        TextFieldDemo(
+            initialState = TextFieldState(
+                input = "",
+                label = "Email Address",
+            ),
+        ) { state ->
+            TextFieldOutlinedEmailAddress(
+                value = state.value.input,
+                label = if (state.value.showLabel) state.value.label else null,
+                onValueChange = { state.value = state.value.copy(input = it) },
+                isEnabled = !state.value.isDisabled,
+                isReadOnly = state.value.isReadOnly,
+                isRequired = state.value.isRequired,
+                hasError = state.value.hasError,
+                modifier = Modifier.fillMaxWidth(),
+            )
+        }
+    }
+}
+
+private fun LazyGridScope.numberTextFieldOutlinedItems() {
+    item {
+        TextFieldDemo(
+            initialState = TextFieldState<Long?>(
+                input = 123L,
+                label = "Number",
+            ),
+        ) { state ->
+            TextFieldOutlinedNumber(
+                value = state.value.input,
+                label = if (state.value.showLabel) state.value.label else null,
+                onValueChange = { state.value = state.value.copy(input = it) },
+                isEnabled = !state.value.isDisabled,
+                isReadOnly = state.value.isReadOnly,
+                isRequired = state.value.isRequired,
+                hasError = state.value.hasError,
+                modifier = Modifier.fillMaxWidth(),
+            )
+        }
+    }
+}
+
+private data class TextFieldSelectState(
+    val options: ImmutableList<String> = persistentListOf("Option 1", "Option 2", "Option 3"),
+    val selectedOption: String = options.first(),
+)
+
+private fun LazyGridScope.selectionTextFieldOutlinedItems() {
+    item {
+        TextFieldDemo(
+            initialState = TextFieldState(
+                input = TextFieldSelectState(),
+                label = "Select",
+            ),
+        ) { state ->
+            key(
+                state.value.input.selectedOption,
+            ) {
+                TextFieldOutlinedSelect(
+                    options = state.value.input.options,
+                    label = if (state.value.showLabel) state.value.label else null,
+                    onValueChange = {
+                        state.value = state.value.copy(input = state.value.input.copy(selectedOption = it))
+                    },
+                    selectedOption = state.value.input.selectedOption,
+                    isEnabled = !state.value.isDisabled,
+                    isReadOnly = state.value.isReadOnly,
+                    isRequired = state.value.isRequired,
+                    hasError = state.value.hasError,
+                    modifier = Modifier.fillMaxWidth(),
+                )
+            }
+        }
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/TypographyItems.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/TypographyItems.kt
new file mode 100644
index 0000000000000000000000000000000000000000..343717b2bfbdaf1fbbba0adbf3783237949c441f
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/atom/items/TypographyItems.kt
@@ -0,0 +1,147 @@
+package app.k9mail.ui.catalog.ui.atom.items
+
+import androidx.compose.foundation.lazy.grid.LazyGridScope
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.withStyle
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextBody1
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextBody2
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextButton
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextCaption
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline1
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline2
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline3
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline4
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline5
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline6
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextOverline
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextSubtitle1
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextSubtitle2
+import app.k9mail.ui.catalog.ui.common.list.itemDefaultPadding
+import app.k9mail.ui.catalog.ui.common.list.sectionHeaderItem
+
+fun LazyGridScope.typographyItems() {
+    sectionHeaderItem(text = "Text styles")
+    textItems()
+
+    sectionHeaderItem(text = "Text styles - Colored")
+    textItems(color = Color.Magenta)
+
+    sectionHeaderItem(text = "Text styles - Annotated")
+    textItems(isAnnotated = true)
+}
+
+@Suppress("LongMethod")
+private fun LazyGridScope.textItems(
+    isAnnotated: Boolean = false,
+    color: Color = Color.Unspecified,
+) {
+    item {
+        TextHeadline1(
+            text = annotatedString("Headline1", isAnnotated),
+            modifier = Modifier.itemDefaultPadding(),
+            color = color,
+        )
+    }
+    item {
+        TextHeadline2(
+            text = annotatedString("Headline2", isAnnotated),
+            modifier = Modifier.itemDefaultPadding(),
+            color = color,
+        )
+    }
+    item {
+        TextHeadline3(
+            text = annotatedString("Headline3", isAnnotated),
+            modifier = Modifier.itemDefaultPadding(),
+            color = color,
+
+        )
+    }
+    item {
+        TextHeadline4(
+            text = annotatedString("Headline4", isAnnotated),
+            modifier = Modifier.itemDefaultPadding(),
+            color = color,
+        )
+    }
+    item {
+        TextHeadline5(
+            text = annotatedString("Headline5", isAnnotated),
+            modifier = Modifier.itemDefaultPadding(),
+            color = color,
+        )
+    }
+
+    item {
+        TextHeadline6(
+            text = annotatedString("Headline6", isAnnotated),
+            modifier = Modifier.itemDefaultPadding(),
+            color = color,
+        )
+    }
+    item {
+        TextSubtitle1(
+            text = annotatedString("Subtitle1", isAnnotated),
+            modifier = Modifier.itemDefaultPadding(),
+            color = color,
+        )
+    }
+    item {
+        TextSubtitle2(
+            text = annotatedString("Subtitle2", isAnnotated),
+            modifier = Modifier.itemDefaultPadding(),
+            color = color,
+        )
+    }
+    item {
+        TextBody1(
+            text = annotatedString("Body1", isAnnotated),
+            modifier = Modifier.itemDefaultPadding(),
+            color = color,
+        )
+    }
+    item {
+        TextBody2(
+            text = annotatedString("Body2", isAnnotated),
+            modifier = Modifier.itemDefaultPadding(),
+            color = color,
+        )
+    }
+    item {
+        TextButton(
+            text = annotatedString("Button", isAnnotated),
+            modifier = Modifier.itemDefaultPadding(),
+            color = color,
+        )
+    }
+    item {
+        TextCaption(
+            text = annotatedString("Caption", isAnnotated),
+            modifier = Modifier.itemDefaultPadding(),
+            color = color,
+        )
+    }
+    item {
+        TextOverline(
+            text = annotatedString("Overline", isAnnotated),
+            modifier = Modifier.itemDefaultPadding(),
+            color = color,
+        )
+    }
+}
+
+private fun annotatedString(
+    name: String,
+    isAnnotated: Boolean,
+) = buildAnnotatedString {
+    append(name)
+    if (isAnnotated) {
+        withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+            append("Annotated")
+        }
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/PagedContent.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/PagedContent.kt
new file mode 100644
index 0000000000000000000000000000000000000000..0a4515045703da93693cfa981acab904ebebfd46
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/PagedContent.kt
@@ -0,0 +1,76 @@
+package app.k9mail.ui.catalog.ui.common
+
+import androidx.compose.foundation.ExperimentalFoundationApi
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.imePadding
+import androidx.compose.foundation.lazy.grid.GridCells
+import androidx.compose.foundation.lazy.grid.LazyGridScope
+import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
+import androidx.compose.foundation.pager.HorizontalPager
+import androidx.compose.foundation.pager.rememberPagerState
+import androidx.compose.material.ScrollableTabRow
+import androidx.compose.material.Tab
+import androidx.compose.material.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import app.k9mail.core.ui.compose.designsystem.template.ResponsiveContentWithBackground
+import app.k9mail.core.ui.compose.theme.MainTheme
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.coroutines.launch
+
+@OptIn(ExperimentalFoundationApi::class)
+@Composable
+fun <T> PagedContent(
+    pages: ImmutableList<T>,
+    initialPage: T,
+    modifier: Modifier = Modifier,
+    onRenderPage: LazyGridScope.(T) -> Unit,
+) {
+    val pagerState = rememberPagerState(initialPage = pages.indexOf(initialPage))
+    val coroutineScope = rememberCoroutineScope()
+
+    Column(
+        modifier = modifier,
+    ) {
+        ScrollableTabRow(
+            selectedTabIndex = pagerState.currentPage,
+        ) {
+            pages.forEachIndexed { index, title ->
+                Tab(
+                    selected = pagerState.currentPage == index,
+                    onClick = {
+                        coroutineScope.launch {
+                            pagerState.animateScrollToPage(index)
+                        }
+                    },
+                    text = { Text(text = title.toString()) },
+                )
+            }
+        }
+        ResponsiveContentWithBackground {
+            HorizontalPager(
+                pageCount = pages.size,
+                state = pagerState,
+                modifier = Modifier
+                    .fillMaxSize(),
+            ) { page ->
+                LazyVerticalGrid(
+                    columns = GridCells.Adaptive(300.dp),
+                    modifier = Modifier.fillMaxSize()
+                        .imePadding(),
+                    horizontalArrangement = Arrangement.spacedBy(MainTheme.spacings.double),
+                    verticalArrangement = Arrangement.spacedBy(MainTheme.spacings.double),
+                ) {
+                    onRenderPage(pages[page])
+                    item { Spacer(modifier = Modifier.height(MainTheme.sizes.smaller)) }
+                }
+            }
+        }
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/ThemeTopAppBar.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/ThemeTopAppBar.kt
new file mode 100644
index 0000000000000000000000000000000000000000..908222286250e34acfd439af7af6e42512deea4d
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/ThemeTopAppBar.kt
@@ -0,0 +1,49 @@
+package app.k9mail.ui.catalog.ui.common
+
+import androidx.compose.material.icons.filled.DarkMode
+import androidx.compose.material.icons.filled.LightMode
+import androidx.compose.material.icons.filled.ShuffleOn
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import app.k9mail.core.ui.compose.designsystem.atom.button.ButtonIcon
+import app.k9mail.core.ui.compose.designsystem.organism.TopAppBar
+import app.k9mail.core.ui.compose.theme.Icons
+import app.k9mail.ui.catalog.ui.CatalogContract.Theme
+import app.k9mail.ui.catalog.ui.CatalogContract.ThemeVariant
+import androidx.compose.material.icons.Icons as MaterialIcons
+
+@Composable
+fun ThemeTopAppBar(
+    onNavigationClick: () -> Unit,
+    theme: Theme,
+    themeVariant: ThemeVariant,
+    onThemeClick: () -> Unit,
+    onThemeVariantClick: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    TopAppBar(
+        title = "${theme.displayName} Catalog",
+        navigationIcon = {
+            ButtonIcon(
+                onClick = onNavigationClick,
+                imageVector = Icons.Outlined.menu,
+            )
+        },
+        actions = {
+            ButtonIcon(
+                onClick = onThemeClick,
+                imageVector = MaterialIcons.Filled.ShuffleOn,
+                contentDescription = "${theme.displayName} Theme",
+            )
+            ButtonIcon(
+                onClick = onThemeVariantClick,
+                imageVector = when (themeVariant) {
+                    ThemeVariant.LIGHT -> MaterialIcons.Filled.DarkMode
+                    ThemeVariant.DARK -> MaterialIcons.Filled.LightMode
+                },
+                contentDescription = "${theme.displayName} Theme Variant",
+            )
+        },
+        modifier = modifier,
+    )
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/drawer/DrawerCategoryItem.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/drawer/DrawerCategoryItem.kt
new file mode 100644
index 0000000000000000000000000000000000000000..a04959d942a2468c2427d7ee7eae6c3599208a3a
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/drawer/DrawerCategoryItem.kt
@@ -0,0 +1,45 @@
+package app.k9mail.ui.catalog.ui.common.drawer
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextSubtitle1
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+
+@Composable
+fun DrawerCategoryItem(
+    text: String,
+    onItemClick: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .clickable { onItemClick() }
+            .then(modifier),
+    ) {
+        TextSubtitle1(
+            text = text,
+            modifier = Modifier.padding(
+                horizontal = MainTheme.spacings.double,
+                vertical = MainTheme.spacings.default,
+            ),
+        )
+    }
+}
+
+@Preview
+@Composable
+fun DrawerCategoryItemPreview() {
+    PreviewWithThemes {
+        DrawerCategoryItem(
+            text = "Text",
+            onItemClick = {},
+        )
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/drawer/DrawerContent.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/drawer/DrawerContent.kt
new file mode 100644
index 0000000000000000000000000000000000000000..f33a77998dd986f28fb5f1b2c5b0cc222ff539c5
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/drawer/DrawerContent.kt
@@ -0,0 +1,89 @@
+package app.k9mail.ui.catalog.ui.common.drawer
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.ui.catalog.ui.CatalogContract.Theme
+import app.k9mail.ui.catalog.ui.CatalogContract.ThemeVariant
+import app.k9mail.ui.catalog.ui.common.theme.ThemeSelector
+import app.k9mail.ui.catalog.ui.common.theme.ThemeVariantSelector
+
+@Suppress("LongParameterList", "LongMethod")
+@Composable
+fun DrawerContent(
+    toggleDrawer: () -> Unit,
+    theme: Theme,
+    themeVariant: ThemeVariant,
+    onThemeChanged: () -> Unit,
+    onThemeVariantChanged: () -> Unit,
+    onNavigateToAtoms: () -> Unit,
+    onNavigateToMolecules: () -> Unit,
+    onNavigateToOrganisms: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    LazyColumn(
+        modifier = modifier,
+        verticalArrangement = Arrangement.spacedBy(MainTheme.spacings.default),
+    ) {
+        item {
+            DrawerHeaderItem(
+                text = "Design system",
+            )
+        }
+        item {
+            DrawerCategoryItem(
+                text = "Atoms",
+                onItemClick = {
+                    toggleDrawer()
+                    onNavigateToAtoms()
+                },
+            )
+        }
+        item {
+            DrawerCategoryItem(
+                text = "Molecules",
+                onItemClick = {
+                    toggleDrawer()
+                    onNavigateToMolecules()
+                },
+            )
+        }
+        item {
+            DrawerCategoryItem(
+                text = "Organisms",
+                onItemClick = {
+                    toggleDrawer()
+                    onNavigateToOrganisms()
+                },
+            )
+        }
+
+        item {
+            DrawerHeaderItem(
+                text = "Theme selection",
+            )
+        }
+        item {
+            ThemeSelector(
+                theme = theme,
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(horizontal = MainTheme.spacings.double),
+                onThemeChangeClick = onThemeChanged,
+            )
+        }
+        item {
+            ThemeVariantSelector(
+                themeVariant = themeVariant,
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(horizontal = MainTheme.spacings.double),
+                onThemeVariantChange = onThemeVariantChanged,
+            )
+        }
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/drawer/DrawerHeaderItem.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/drawer/DrawerHeaderItem.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d176eb537281a39db2326755cbc96804324495bb
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/drawer/DrawerHeaderItem.kt
@@ -0,0 +1,44 @@
+package app.k9mail.ui.catalog.ui.common.drawer
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.designsystem.atom.Divider
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline6
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+
+@Composable
+fun DrawerHeaderItem(
+    text: String,
+    modifier: Modifier = Modifier,
+) {
+    Column(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(
+                start = MainTheme.spacings.double,
+                top = MainTheme.spacings.double,
+                end = MainTheme.spacings.double,
+            )
+            .then(modifier),
+    ) {
+        TextHeadline6(
+            text = text,
+        )
+        Divider()
+    }
+}
+
+@Preview
+@Composable
+fun DrawerHeaderItemPreview() {
+    PreviewWithThemes {
+        DrawerHeaderItem(
+            text = "Category",
+        )
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/helper/WithRememberedState.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/helper/WithRememberedState.kt
new file mode 100644
index 0000000000000000000000000000000000000000..3aa78eaf6122870cd6eb3a90c5ad50667435fa06
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/helper/WithRememberedState.kt
@@ -0,0 +1,15 @@
+package app.k9mail.ui.catalog.ui.common.helper
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+
+@Composable
+internal fun <T> WithRememberedState(
+    input: T,
+    content: @Composable (state: MutableState<T>) -> Unit,
+) {
+    val state = remember { mutableStateOf(input) }
+    content(state)
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/list/ItemDefaultPadding.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/list/ItemDefaultPadding.kt
new file mode 100644
index 0000000000000000000000000000000000000000..54a2cf5362975e7e2eed4687100bd86442ec6d1e
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/list/ItemDefaultPadding.kt
@@ -0,0 +1,12 @@
+package app.k9mail.ui.catalog.ui.common.list
+
+import androidx.compose.foundation.layout.padding
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.composed
+import app.k9mail.core.ui.compose.theme.MainTheme
+
+fun Modifier.itemDefaultPadding(): Modifier = composed {
+    padding(
+        horizontal = MainTheme.spacings.double,
+    )
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/list/ItemOutlined.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/list/ItemOutlined.kt
new file mode 100644
index 0000000000000000000000000000000000000000..1fa775549e71ef63e204c9626f61da8f5394f7db
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/list/ItemOutlined.kt
@@ -0,0 +1,33 @@
+package app.k9mail.ui.catalog.ui.common.list
+
+import androidx.compose.foundation.border
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.dp
+import app.k9mail.core.ui.compose.theme.MainTheme
+
+@Composable
+fun ItemOutlined(
+    modifier: Modifier = Modifier,
+    content: @Composable () -> Unit,
+) {
+    Column(
+        verticalArrangement = Arrangement.spacedBy(MainTheme.spacings.default),
+        modifier = Modifier
+            .itemDefaultPadding()
+            .then(modifier),
+    ) {
+        Box(
+            modifier = Modifier
+                .border(1.dp, Color.Gray)
+                .fillMaxWidth(),
+        ) {
+            content()
+        }
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/list/SectionHeaderItem.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/list/SectionHeaderItem.kt
new file mode 100644
index 0000000000000000000000000000000000000000..3d9cd8bc738581c8937e0b9243626b987122f1a3
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/list/SectionHeaderItem.kt
@@ -0,0 +1,32 @@
+package app.k9mail.ui.catalog.ui.common.list
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.grid.GridItemSpan
+import androidx.compose.foundation.lazy.grid.LazyGridScope
+import androidx.compose.ui.Modifier
+import app.k9mail.core.ui.compose.designsystem.atom.Divider
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline6
+import app.k9mail.core.ui.compose.theme.MainTheme
+
+fun LazyGridScope.sectionHeaderItem(
+    text: String,
+) {
+    item(span = { GridItemSpan(maxLineSpan) }) {
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(
+                    start = MainTheme.spacings.double,
+                    top = MainTheme.spacings.double,
+                    end = MainTheme.spacings.double,
+                ),
+        ) {
+            TextHeadline6(
+                text = text,
+            )
+            Divider()
+        }
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/list/SectionSubtitleItem.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/list/SectionSubtitleItem.kt
new file mode 100644
index 0000000000000000000000000000000000000000..be8432e20031450213ac5e44f7aeb4b77ab8eccf
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/list/SectionSubtitleItem.kt
@@ -0,0 +1,32 @@
+package app.k9mail.ui.catalog.ui.common.list
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.grid.GridItemSpan
+import androidx.compose.foundation.lazy.grid.LazyGridScope
+import androidx.compose.ui.Modifier
+import app.k9mail.core.ui.compose.designsystem.atom.Divider
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextSubtitle1
+import app.k9mail.core.ui.compose.theme.MainTheme
+
+fun LazyGridScope.sectionSubtitleItem(
+    text: String,
+) {
+    item(span = { GridItemSpan(maxLineSpan) }) {
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(
+                    start = MainTheme.spacings.double,
+                    top = MainTheme.spacings.default,
+                    end = MainTheme.spacings.double,
+                ),
+        ) {
+            TextSubtitle1(
+                text = text,
+            )
+            Divider()
+        }
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogThemeSelector.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/theme/ThemeSelector.kt
similarity index 81%
rename from app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogThemeSelector.kt
rename to app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/theme/ThemeSelector.kt
index 88896fa40d17a5e9b8bec62defb293fe100920c9..80a37e14aa464d7dde49821fdc1a116eecbc6018 100644
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogThemeSelector.kt
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/theme/ThemeSelector.kt
@@ -1,4 +1,4 @@
-package app.k9mail.ui.catalog
+package app.k9mail.ui.catalog.ui.common.theme
 
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Row
@@ -8,10 +8,11 @@ import androidx.compose.ui.Modifier
 import app.k9mail.core.ui.compose.designsystem.atom.button.Button
 import app.k9mail.core.ui.compose.designsystem.atom.text.TextBody1
 import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.ui.catalog.ui.CatalogContract.Theme
 
 @Composable
-fun CatalogThemeSelector(
-    catalogTheme: CatalogTheme,
+fun ThemeSelector(
+    theme: Theme,
     modifier: Modifier = Modifier,
     onThemeChangeClick: () -> Unit,
 ) {
@@ -22,7 +23,7 @@ fun CatalogThemeSelector(
     ) {
         TextBody1(text = "Change theme:")
         Button(
-            text = catalogTheme.toString(),
+            text = theme.toString(),
             onClick = onThemeChangeClick,
         )
     }
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogThemeSwitch.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/theme/ThemeSwitch.kt
similarity index 62%
rename from app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogThemeSwitch.kt
rename to app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/theme/ThemeSwitch.kt
index 116c05a4d1cbd34de873ff72bc7a57063cc33f2d..5d5e8098f6271c5be7b9542b96a3f0e20e5e42a9 100644
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogThemeSwitch.kt
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/theme/ThemeSwitch.kt
@@ -1,21 +1,23 @@
-package app.k9mail.ui.catalog
+package app.k9mail.ui.catalog.ui.common.theme
 
 import androidx.compose.runtime.Composable
 import app.k9mail.core.ui.compose.theme.K9Theme
 import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
+import app.k9mail.ui.catalog.ui.CatalogContract.Theme
+import app.k9mail.ui.catalog.ui.CatalogContract.ThemeVariant
 
 @Composable
-fun CatalogThemeSwitch(
-    theme: CatalogTheme,
-    themeVariant: CatalogThemeVariant,
+fun ThemeSwitch(
+    theme: Theme,
+    themeVariant: ThemeVariant,
     content: @Composable () -> Unit,
 ) {
     when (theme) {
-        CatalogTheme.K9 -> K9ThemeSwitch(
+        Theme.K9 -> K9ThemeSwitch(
             themeVariant = themeVariant,
             content = content,
         )
-        CatalogTheme.THUNDERBIRD -> ThunderbirdThemeSwitch(
+        Theme.THUNDERBIRD -> ThunderbirdThemeSwitch(
             themeVariant = themeVariant,
             content = content,
         )
@@ -24,15 +26,15 @@ fun CatalogThemeSwitch(
 
 @Composable
 private fun K9ThemeSwitch(
-    themeVariant: CatalogThemeVariant,
+    themeVariant: ThemeVariant,
     content: @Composable () -> Unit,
 ) {
     when (themeVariant) {
-        CatalogThemeVariant.LIGHT -> K9Theme(
+        ThemeVariant.LIGHT -> K9Theme(
             darkTheme = false,
             content = content,
         )
-        CatalogThemeVariant.DARK -> K9Theme(
+        ThemeVariant.DARK -> K9Theme(
             darkTheme = true,
             content = content,
         )
@@ -41,15 +43,15 @@ private fun K9ThemeSwitch(
 
 @Composable
 private fun ThunderbirdThemeSwitch(
-    themeVariant: CatalogThemeVariant,
+    themeVariant: ThemeVariant,
     content: @Composable () -> Unit,
 ) {
     when (themeVariant) {
-        CatalogThemeVariant.LIGHT -> ThunderbirdTheme(
+        ThemeVariant.LIGHT -> ThunderbirdTheme(
             darkTheme = false,
             content = content,
         )
-        CatalogThemeVariant.DARK -> ThunderbirdTheme(
+        ThemeVariant.DARK -> ThunderbirdTheme(
             darkTheme = true,
             content = content,
         )
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogThemeVariantSelector.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/theme/ThemeVariantSelector.kt
similarity index 74%
rename from app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogThemeVariantSelector.kt
rename to app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/theme/ThemeVariantSelector.kt
index aeafed5c0da5953eb4fbc2b94952d465874ebec7..5bc12a522047c6a14a33e1aa085a822e6ee8edba 100644
--- a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/CatalogThemeVariantSelector.kt
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/common/theme/ThemeVariantSelector.kt
@@ -1,4 +1,4 @@
-package app.k9mail.ui.catalog
+package app.k9mail.ui.catalog.ui.common.theme
 
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Row
@@ -8,10 +8,11 @@ import androidx.compose.ui.Modifier
 import app.k9mail.core.ui.compose.designsystem.atom.Checkbox
 import app.k9mail.core.ui.compose.designsystem.atom.text.TextBody1
 import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.ui.catalog.ui.CatalogContract.ThemeVariant
 
 @Composable
-fun CatalogThemeVariantSelector(
-    catalogThemeVariant: CatalogThemeVariant,
+fun ThemeVariantSelector(
+    themeVariant: ThemeVariant,
     modifier: Modifier = Modifier,
     onThemeVariantChange: () -> Unit,
 ) {
@@ -20,9 +21,9 @@ fun CatalogThemeVariantSelector(
         verticalAlignment = Alignment.CenterVertically,
         horizontalArrangement = Arrangement.spacedBy(MainTheme.spacings.default),
     ) {
-        TextBody1(text = "Dark mode:")
+        TextBody1(text = "Enable dark mode:")
         Checkbox(
-            checked = catalogThemeVariant == CatalogThemeVariant.DARK,
+            checked = themeVariant == ThemeVariant.DARK,
             onCheckedChange = { onThemeVariantChange() },
         )
     }
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/CatalogMoleculeContent.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/CatalogMoleculeContent.kt
new file mode 100644
index 0000000000000000000000000000000000000000..caa1241f1d883516537c9f9dd19cb09a162d279d
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/CatalogMoleculeContent.kt
@@ -0,0 +1,28 @@
+package app.k9mail.ui.catalog.ui.molecule
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import app.k9mail.ui.catalog.ui.common.PagedContent
+import app.k9mail.ui.catalog.ui.molecule.CatalogMoleculePage.INPUT
+import app.k9mail.ui.catalog.ui.molecule.CatalogMoleculePage.STATE
+import app.k9mail.ui.catalog.ui.molecule.items.inputItems
+import app.k9mail.ui.catalog.ui.molecule.items.stateItems
+import kotlinx.collections.immutable.ImmutableList
+
+@Composable
+fun CatalogMoleculeContent(
+    pages: ImmutableList<CatalogMoleculePage>,
+    initialPage: CatalogMoleculePage,
+    modifier: Modifier = Modifier,
+) {
+    PagedContent(
+        pages = pages,
+        initialPage = initialPage,
+        modifier = modifier,
+    ) {
+        when (it) {
+            INPUT -> inputItems()
+            STATE -> stateItems()
+        }
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/CatalogMoleculeNavigation.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/CatalogMoleculeNavigation.kt
new file mode 100644
index 0000000000000000000000000000000000000000..aa28844c96a0d5da3b2026782dcdb032a53c3bd7
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/CatalogMoleculeNavigation.kt
@@ -0,0 +1,23 @@
+package app.k9mail.ui.catalog.ui.molecule
+
+import androidx.navigation.NavController
+import androidx.navigation.NavGraphBuilder
+import androidx.navigation.NavOptions
+import androidx.navigation.compose.composable
+
+const val NAVIGATION_ROUTE_CATALOG_MOLECULE = "/catalog/molecule"
+
+fun NavController.navigateToCatalogMolecule() {
+    navigate(
+        route = NAVIGATION_ROUTE_CATALOG_MOLECULE,
+        navOptions = NavOptions.Builder()
+            .setLaunchSingleTop(true)
+            .build(),
+    )
+}
+
+fun NavGraphBuilder.catalogMoleculeRoute() {
+    composable(route = NAVIGATION_ROUTE_CATALOG_MOLECULE) {
+        CatalogMoleculeScreen()
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/CatalogMoleculePage.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/CatalogMoleculePage.kt
new file mode 100644
index 0000000000000000000000000000000000000000..cfd4018c21c769187ed09cea7bc64dfd53a472f3
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/CatalogMoleculePage.kt
@@ -0,0 +1,19 @@
+package app.k9mail.ui.catalog.ui.molecule
+
+import kotlinx.collections.immutable.toImmutableList
+
+enum class CatalogMoleculePage(
+    private val displayName: String,
+) {
+    INPUT("Inputs"),
+    STATE("States"),
+    ;
+
+    override fun toString(): String {
+        return displayName
+    }
+
+    companion object {
+        fun all() = values().toList().toImmutableList()
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/CatalogMoleculeScreen.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/CatalogMoleculeScreen.kt
new file mode 100644
index 0000000000000000000000000000000000000000..b51282ae963a59b4be448e96b2f4685beb3c8893
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/CatalogMoleculeScreen.kt
@@ -0,0 +1,15 @@
+package app.k9mail.ui.catalog.ui.molecule
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+
+@Composable
+fun CatalogMoleculeScreen(
+    modifier: Modifier = Modifier,
+) {
+    CatalogMoleculeContent(
+        pages = CatalogMoleculePage.all(),
+        initialPage = CatalogMoleculePage.INPUT,
+        modifier = modifier,
+    )
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/items/InputItems.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/items/InputItems.kt
new file mode 100644
index 0000000000000000000000000000000000000000..f186d871b34460db746c56237694afc9163fce7a
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/items/InputItems.kt
@@ -0,0 +1,186 @@
+package app.k9mail.ui.catalog.ui.molecule.items
+
+import androidx.compose.foundation.lazy.grid.LazyGridScope
+import app.k9mail.core.ui.compose.designsystem.molecule.input.CheckboxInput
+import app.k9mail.core.ui.compose.designsystem.molecule.input.EmailAddressInput
+import app.k9mail.core.ui.compose.designsystem.molecule.input.NumberInput
+import app.k9mail.core.ui.compose.designsystem.molecule.input.PasswordInput
+import app.k9mail.core.ui.compose.designsystem.molecule.input.SelectInput
+import app.k9mail.core.ui.compose.designsystem.molecule.input.SwitchInput
+import app.k9mail.core.ui.compose.designsystem.molecule.input.TextInput
+import app.k9mail.ui.catalog.ui.common.helper.WithRememberedState
+import app.k9mail.ui.catalog.ui.common.list.ItemOutlined
+import app.k9mail.ui.catalog.ui.common.list.sectionHeaderItem
+import app.k9mail.ui.catalog.ui.common.list.sectionSubtitleItem
+import kotlinx.collections.immutable.persistentListOf
+
+@Suppress("LongMethod")
+fun LazyGridScope.inputItems() {
+    sectionHeaderItem(text = "TextInput")
+    sectionSubtitleItem(text = "Default")
+    item {
+        ItemOutlined {
+            WithRememberedState(input = "") { state ->
+                TextInput(
+                    text = state.value,
+                    onTextChange = { state.value = it },
+                )
+            }
+        }
+    }
+    sectionSubtitleItem(text = "With error")
+    item {
+        ItemOutlined {
+            WithRememberedState(input = "") { state ->
+                TextInput(
+                    text = state.value,
+                    onTextChange = { state.value = it },
+                    errorMessage = "Invalid input",
+                )
+            }
+        }
+    }
+
+    sectionHeaderItem(text = "EmailAddressInput")
+    sectionSubtitleItem(text = "Default")
+    item {
+        ItemOutlined {
+            WithRememberedState(input = "") { state ->
+                EmailAddressInput(
+                    emailAddress = state.value,
+                    onEmailAddressChange = { state.value = it },
+                )
+            }
+        }
+    }
+    sectionSubtitleItem(text = "With error")
+    item {
+        ItemOutlined {
+            WithRememberedState(input = "wrong email address") { state ->
+                EmailAddressInput(
+                    emailAddress = state.value,
+                    onEmailAddressChange = { state.value = it },
+                    errorMessage = "Invalid email address",
+                )
+            }
+        }
+    }
+
+    sectionHeaderItem(text = "NumberInput")
+    sectionSubtitleItem(text = "Default")
+    item {
+        ItemOutlined {
+            WithRememberedState<Long?>(input = null) { state ->
+                NumberInput(
+                    value = state.value,
+                    onValueChange = { state.value = it },
+                )
+            }
+        }
+    }
+    sectionSubtitleItem(text = "With error")
+    item {
+        ItemOutlined {
+            WithRememberedState<Long?>(input = 123L) { state ->
+                NumberInput(
+                    value = state.value,
+                    onValueChange = { state.value = it },
+                    errorMessage = "Invalid number",
+                )
+            }
+        }
+    }
+
+    sectionHeaderItem(text = "PasswordInput")
+    sectionSubtitleItem(text = "Default")
+    item {
+        ItemOutlined {
+            WithRememberedState(input = "") { state ->
+                PasswordInput(
+                    password = state.value,
+                    onPasswordChange = { state.value = it },
+                )
+            }
+        }
+    }
+    sectionSubtitleItem(text = "With error")
+    item {
+        ItemOutlined {
+            WithRememberedState(input = "wrong password") { state ->
+                PasswordInput(
+                    password = state.value,
+                    onPasswordChange = { state.value = it },
+                    errorMessage = "Invalid password",
+                )
+            }
+        }
+    }
+
+    sectionHeaderItem(text = "SelectInput")
+    item {
+        val options = persistentListOf("Option 1", "Option 2", "Option 3")
+        ItemOutlined {
+            WithRememberedState(input = options.first()) { state ->
+                SelectInput(
+                    options = options,
+                    selectedOption = state.value,
+                    onOptionChange = { state.value = it },
+                )
+            }
+        }
+    }
+
+    sectionHeaderItem(text = "CheckboxInput")
+    sectionSubtitleItem(text = "Default")
+    item {
+        ItemOutlined {
+            WithRememberedState(input = false) { state ->
+                CheckboxInput(
+                    text = "Check the box",
+                    checked = state.value,
+                    onCheckedChange = { state.value = it },
+                )
+            }
+        }
+    }
+    sectionSubtitleItem(text = "With error")
+    item {
+        ItemOutlined {
+            WithRememberedState(input = false) { state ->
+                CheckboxInput(
+                    text = "Check the box",
+                    checked = state.value,
+                    onCheckedChange = { state.value = it },
+                    errorMessage = "Checkbox must be checked",
+                )
+            }
+        }
+    }
+
+    sectionHeaderItem(text = "SwitchInput")
+    sectionSubtitleItem(text = "Default")
+    item {
+        ItemOutlined {
+            WithRememberedState(input = false) { state ->
+                SwitchInput(
+                    text = "Switch the toggle",
+                    checked = state.value,
+                    onCheckedChange = { state.value = it },
+                )
+            }
+        }
+    }
+    sectionSubtitleItem(text = "With error")
+    item {
+        ItemOutlined {
+            WithRememberedState(input = false) { state ->
+                SwitchInput(
+                    text = "Switch the toggle",
+                    checked = state.value,
+                    onCheckedChange = { state.value = it },
+                    errorMessage = "Switch must be checked",
+                )
+            }
+        }
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/items/StateItems.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/items/StateItems.kt
new file mode 100644
index 0000000000000000000000000000000000000000..3bd37e2fa1aecf6f5890c1828ad602a9af9733c4
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/molecule/items/StateItems.kt
@@ -0,0 +1,36 @@
+package app.k9mail.ui.catalog.ui.molecule.items
+
+import androidx.compose.foundation.lazy.grid.LazyGridScope
+import app.k9mail.core.ui.compose.designsystem.molecule.ErrorView
+import app.k9mail.core.ui.compose.designsystem.molecule.LoadingView
+import app.k9mail.ui.catalog.ui.common.list.ItemOutlined
+import app.k9mail.ui.catalog.ui.common.list.sectionHeaderItem
+import app.k9mail.ui.catalog.ui.common.list.sectionSubtitleItem
+
+fun LazyGridScope.stateItems() {
+    sectionHeaderItem(text = "ErrorView")
+    item {
+        ItemOutlined {
+            ErrorView(
+                title = "Error",
+                message = "Something went wrong",
+            )
+        }
+    }
+
+    sectionHeaderItem(text = "LoadingView")
+    sectionSubtitleItem(text = "Default")
+    item {
+        ItemOutlined {
+            LoadingView()
+        }
+    }
+    sectionSubtitleItem(text = "With message")
+    item {
+        ItemOutlined {
+            LoadingView(
+                message = "Loading...",
+            )
+        }
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/navigation/CatalogNavHost.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/navigation/CatalogNavHost.kt
new file mode 100644
index 0000000000000000000000000000000000000000..50487d8aeacc0594b135ab310da08804d03dc186
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/navigation/CatalogNavHost.kt
@@ -0,0 +1,27 @@
+package app.k9mail.ui.catalog.ui.navigation
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.navigation.NavHostController
+import androidx.navigation.compose.NavHost
+import app.k9mail.ui.catalog.ui.atom.NAVIGATION_ROUTE_CATALOG_ATOM
+import app.k9mail.ui.catalog.ui.atom.catalogAtomRoute
+import app.k9mail.ui.catalog.ui.molecule.catalogMoleculeRoute
+import app.k9mail.ui.catalog.ui.organism.catalogOrganismRoute
+
+@Composable
+fun CatalogNavHost(
+    navController: NavHostController,
+    modifier: Modifier = Modifier,
+    startDestination: String = NAVIGATION_ROUTE_CATALOG_ATOM,
+) {
+    NavHost(
+        navController = navController,
+        startDestination = startDestination,
+        modifier = modifier,
+    ) {
+        catalogAtomRoute()
+        catalogMoleculeRoute()
+        catalogOrganismRoute()
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/organism/CatalogMoleculeContent.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/organism/CatalogMoleculeContent.kt
new file mode 100644
index 0000000000000000000000000000000000000000..9a15d23e28f172abdd001cbd79873dcd16024c6a
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/organism/CatalogMoleculeContent.kt
@@ -0,0 +1,25 @@
+package app.k9mail.ui.catalog.ui.organism
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import app.k9mail.ui.catalog.ui.common.PagedContent
+import app.k9mail.ui.catalog.ui.organism.CatalogOrganismPage.APP_BAR
+import app.k9mail.ui.catalog.ui.organism.items.appBarItems
+import kotlinx.collections.immutable.ImmutableList
+
+@Composable
+fun CatalogOrganismContent(
+    pages: ImmutableList<CatalogOrganismPage>,
+    initialPage: CatalogOrganismPage,
+    modifier: Modifier = Modifier,
+) {
+    PagedContent(
+        pages = pages,
+        initialPage = initialPage,
+        modifier = modifier,
+    ) {
+        when (it) {
+            APP_BAR -> appBarItems()
+        }
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/organism/CatalogMoleculeNavigation.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/organism/CatalogMoleculeNavigation.kt
new file mode 100644
index 0000000000000000000000000000000000000000..9ff63c3f6df00cd790aea70e1250cc59ff468388
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/organism/CatalogMoleculeNavigation.kt
@@ -0,0 +1,23 @@
+package app.k9mail.ui.catalog.ui.organism
+
+import androidx.navigation.NavController
+import androidx.navigation.NavGraphBuilder
+import androidx.navigation.NavOptions
+import androidx.navigation.compose.composable
+
+const val NAVIGATION_ROUTE_CATALOG_ORGANISM = "/catalog/organism"
+
+fun NavController.navigateToCatalogOrganism() {
+    navigate(
+        route = NAVIGATION_ROUTE_CATALOG_ORGANISM,
+        navOptions = NavOptions.Builder()
+            .setLaunchSingleTop(true)
+            .build(),
+    )
+}
+
+fun NavGraphBuilder.catalogOrganismRoute() {
+    composable(route = NAVIGATION_ROUTE_CATALOG_ORGANISM) {
+        CatalogOrganismScreen()
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/organism/CatalogOrganismPage.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/organism/CatalogOrganismPage.kt
new file mode 100644
index 0000000000000000000000000000000000000000..1f2c4a405941df493a2da44576554ce92ef09dd0
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/organism/CatalogOrganismPage.kt
@@ -0,0 +1,18 @@
+package app.k9mail.ui.catalog.ui.organism
+
+import kotlinx.collections.immutable.toImmutableList
+
+enum class CatalogOrganismPage(
+    private val displayName: String,
+) {
+    APP_BAR("App Bars"),
+    ;
+
+    override fun toString(): String {
+        return displayName
+    }
+
+    companion object {
+        fun all() = values().toList().toImmutableList()
+    }
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/organism/CatalogOrganismScreen.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/organism/CatalogOrganismScreen.kt
new file mode 100644
index 0000000000000000000000000000000000000000..7c6fb5e2e5df7aac7e8352b04188eeb6ed1370a5
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/organism/CatalogOrganismScreen.kt
@@ -0,0 +1,15 @@
+package app.k9mail.ui.catalog.ui.organism
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+
+@Composable
+fun CatalogOrganismScreen(
+    modifier: Modifier = Modifier,
+) {
+    CatalogOrganismContent(
+        pages = CatalogOrganismPage.all(),
+        initialPage = CatalogOrganismPage.APP_BAR,
+        modifier = modifier,
+    )
+}
diff --git a/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/organism/items/AppBarItems.kt b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/organism/items/AppBarItems.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c87d1a326557c3436a98719d65b5fb4df1cdfb23
--- /dev/null
+++ b/app-ui-catalog/src/main/java/app/k9mail/ui/catalog/ui/organism/items/AppBarItems.kt
@@ -0,0 +1,94 @@
+package app.k9mail.ui.catalog.ui.organism.items
+
+import androidx.compose.foundation.lazy.grid.LazyGridScope
+import androidx.compose.material.Icon
+import androidx.compose.material.IconButton
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.vector.ImageVector
+import app.k9mail.core.ui.compose.designsystem.organism.TopAppBar
+import app.k9mail.core.ui.compose.theme.Icons
+import app.k9mail.ui.catalog.ui.common.list.ItemOutlined
+import app.k9mail.ui.catalog.ui.common.list.sectionHeaderItem
+import app.k9mail.ui.catalog.ui.common.list.sectionSubtitleItem
+
+fun LazyGridScope.appBarItems() {
+    sectionHeaderItem(text = "TopAppBar")
+    sectionSubtitleItem(text = "With menu icon")
+    item {
+        ItemOutlined {
+            TopAppBarItem(
+                title = "Title",
+                navIcon = Icons.Outlined.menu,
+                actionIcon = Icons.Filled.user,
+            )
+        }
+    }
+    sectionSubtitleItem(text = "With back icon")
+    item {
+        ItemOutlined {
+            TopAppBarItem(
+                title = "Title",
+                navIcon = Icons.Outlined.arrowBack,
+                actionIcon = Icons.Filled.inbox,
+            )
+        }
+    }
+    sectionSubtitleItem(text = "With subtitle")
+    item {
+        ItemOutlined {
+            TopAppBarItem(
+                title = "Title",
+                subtitle = "Subtitle",
+                navIcon = Icons.Outlined.menu,
+                actionIcon = Icons.Filled.user,
+            )
+        }
+    }
+    sectionSubtitleItem(text = "With subtitle and no nav icon")
+    item {
+        ItemOutlined {
+            TopAppBarItem(
+                title = "Title",
+                subtitle = "Subtitle",
+                navIcon = null,
+                actionIcon = Icons.Filled.user,
+            )
+        }
+    }
+}
+
+@Composable
+fun TopAppBarItem(
+    title: String,
+    actionIcon: ImageVector,
+    modifier: Modifier = Modifier,
+    subtitle: String? = null,
+    navIcon: ImageVector? = null,
+) {
+    TopAppBar(
+        title = title,
+        subtitle = subtitle,
+        navigationIcon = if (navIcon != null) {
+            {
+                IconButton(onClick = {}) {
+                    Icon(
+                        imageVector = navIcon,
+                        contentDescription = null,
+                    )
+                }
+            }
+        } else {
+            null
+        },
+        actions = {
+            IconButton(onClick = {}) {
+                Icon(
+                    imageVector = actionIcon,
+                    contentDescription = null,
+                )
+            }
+        },
+        modifier = modifier,
+    )
+}
diff --git a/app-ui-catalog/src/main/res/values/colors.xml b/app-ui-catalog/src/main/res/values/colors.xml
index 62d0f537469bc5b0d5893f8f2efa96298777175b..87b596108170064a40ead9bf8d69bb7ff970b6c3 100644
--- a/app-ui-catalog/src/main/res/values/colors.xml
+++ b/app-ui-catalog/src/main/res/values/colors.xml
@@ -1,9 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
-    <!--  Material orange 300  -->
-    <color name="ic_launcher_logo_main">#FFB74D</color>
-    <!--  Material orange 700  -->
-    <color name="ic_launcher_logo_shadow">#F57C00</color>
     <!--  Material orange 50  -->
     <color name="ic_launcher_background">#FFFF7300</color>
 </resources>
diff --git a/app-ui-catalog/src/main/res/values/themes.xml b/app-ui-catalog/src/main/res/values/themes.xml
index 5bfdb913ac697a755a7c0ebd6608b5b006c53330..b784534a72714ddc8861f4cbd13ade270e46671d 100644
--- a/app-ui-catalog/src/main/res/values/themes.xml
+++ b/app-ui-catalog/src/main/res/values/themes.xml
@@ -1,6 +1,9 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
-    <style name="Theme.Thunderbird" parent="Theme.MaterialComponents.DayNight.NoActionBar" />
+    <style name="Theme.Thunderbird" parent="Theme.MaterialComponents.DayNight.NoActionBar">
+        <item name="android:statusBarColor">@android:color/transparent</item>
+        <item name="android:navigationBarColor">@android:color/transparent</item>
+    </style>
 
     <style name="Theme.Thunderbird.Splashscreen" parent="Theme.SplashScreen">
         <item name="windowSplashScreenAnimatedIcon">@drawable/ic_launcher_foreground</item>
diff --git a/app/core/build.gradle.kts b/app/core/build.gradle.kts
index b33a85c02c84ceb3d9068626a4da29aab827fb0f..7ba0b6816e508ff0ed1401c84ba9ca5db701d231 100644
--- a/app/core/build.gradle.kts
+++ b/app/core/build.gradle.kts
@@ -28,6 +28,7 @@ dependencies {
     implementation(libs.mime4j.dom)
 
     testApi(projects.core.testing)
+    testApi(projects.core.android.testing)
     testImplementation(projects.mail.testing)
     testImplementation(projects.backend.imap)
     testImplementation(projects.mail.protocols.smtp)
diff --git a/app/core/src/main/java/com/fsck/k9/KoinModule.kt b/app/core/src/main/java/com/fsck/k9/KoinModule.kt
index 3c438938016bf883f917cd0a8b65c09e0b5b4d2a..d3ad9c079c995946aa22887f97a57a7997abf9ca 100644
--- a/app/core/src/main/java/com/fsck/k9/KoinModule.kt
+++ b/app/core/src/main/java/com/fsck/k9/KoinModule.kt
@@ -8,7 +8,6 @@ import com.fsck.k9.mail.ssl.LocalKeyStore
 import com.fsck.k9.mail.ssl.TrustManagerFactory
 import com.fsck.k9.mail.ssl.TrustedSocketFactory
 import com.fsck.k9.mailstore.LocalStoreProvider
-import com.fsck.k9.setup.ServerNameSuggester
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.GlobalScope
 import kotlinx.datetime.Clock
@@ -34,7 +33,6 @@ val mainModule = module {
     single { LocalKeyStoreManager(get()) }
     single<TrustedSocketFactory> { DefaultTrustedSocketFactory(get(), get()) }
     single<Clock> { Clock.System }
-    factory { ServerNameSuggester() }
     factory { EmailAddressValidator() }
     factory { ServerSettingsSerializer() }
 }
diff --git a/app/core/src/main/java/com/fsck/k9/controller/MessagingController.java b/app/core/src/main/java/com/fsck/k9/controller/MessagingController.java
index e3396031efdbd1b5af382773940d70eb6ea7aff5..82876d5f9466c9e5d957b66968b982c01d4717e2 100644
--- a/app/core/src/main/java/com/fsck/k9/controller/MessagingController.java
+++ b/app/core/src/main/java/com/fsck/k9/controller/MessagingController.java
@@ -1528,8 +1528,8 @@ public class MessagingController {
 
                     SendState sendState = outboxState.getSendState();
                     if (sendState != SendState.READY) {
-                        Timber.v("Skipping sending message %s (reason: %s)", message.getUid(),
-                                sendState.getDatabaseName());
+                        Timber.v("Skipping sending message %s (reason: %s - %s)", message.getUid(),
+                                sendState.getDatabaseName(), outboxState.getSendError());
 
                         if (sendState == SendState.RETRIES_EXCEEDED) {
                             lastFailure = new MessagingException("Retries exceeded", true);
@@ -1702,6 +1702,10 @@ public class MessagingController {
         return getBackend(account).getSupportsUpload();
     }
 
+    public boolean supportsFolderSubscriptions(Account account) {
+        return getBackend(account).getSupportsFolderSubscriptions();
+    }
+
     public void checkIncomingServerSettings(Account account) throws MessagingException {
         getBackend(account).checkIncomingServerSettings();
     }
diff --git a/app/core/src/main/java/com/fsck/k9/helper/ContactNameProvider.kt b/app/core/src/main/java/com/fsck/k9/helper/ContactNameProvider.kt
index 4d16061b9649f81ec408b54a21b488ffcafdfc57..1e354c987b690892b07a09db3cd26e2259a4ad93 100644
--- a/app/core/src/main/java/com/fsck/k9/helper/ContactNameProvider.kt
+++ b/app/core/src/main/java/com/fsck/k9/helper/ContactNameProvider.kt
@@ -1,7 +1,7 @@
 package com.fsck.k9.helper
 
 import app.k9mail.core.android.common.contact.ContactRepository
-import app.k9mail.core.common.mail.EmailAddress
+import app.k9mail.core.common.mail.toEmailAddressOrNull
 
 interface ContactNameProvider {
     fun getNameForAddress(address: String): String?
@@ -11,6 +11,8 @@ class RealContactNameProvider(
     private val contactRepository: ContactRepository,
 ) : ContactNameProvider {
     override fun getNameForAddress(address: String): String? {
-        return contactRepository.getContactFor(EmailAddress(address))?.name
+        return address.toEmailAddressOrNull()?.let { emailAddress ->
+            contactRepository.getContactFor(emailAddress)?.name
+        }
     }
 }
diff --git a/app/core/src/main/java/com/fsck/k9/helper/MessageHelper.kt b/app/core/src/main/java/com/fsck/k9/helper/MessageHelper.kt
index f5a7a160d96340fcd8a9c6c66ce23a6836ab68c5..a36dc77909d5602561aa59fdd199a68ed6e53d52 100644
--- a/app/core/src/main/java/com/fsck/k9/helper/MessageHelper.kt
+++ b/app/core/src/main/java/com/fsck/k9/helper/MessageHelper.kt
@@ -6,7 +6,7 @@ import android.text.SpannableStringBuilder
 import android.text.TextUtils
 import android.text.style.ForegroundColorSpan
 import app.k9mail.core.android.common.contact.ContactRepository
-import app.k9mail.core.common.mail.EmailAddress
+import app.k9mail.core.common.mail.toEmailAddressOrNull
 import com.fsck.k9.CoreResourceProvider
 import com.fsck.k9.K9.contactNameColor
 import com.fsck.k9.K9.isChangeContactNameColor
@@ -101,7 +101,7 @@ class MessageHelper(
             if (!showCorrespondentNames) {
                 return address.address
             } else if (contactRepository != null) {
-                val name = contactRepository.getContactFor(EmailAddress(address.address))?.name
+                val name = contactRepository.getContactName(address)
                 if (name != null) {
                     return if (changeContactNameColor) {
                         val coloredName = SpannableString(name)
@@ -124,6 +124,12 @@ class MessageHelper(
             }
         }
 
+        private fun ContactRepository.getContactName(address: Address): String? {
+            return address.address.toEmailAddressOrNull()?.let { emailAddress ->
+                getContactFor(emailAddress)?.name
+            }
+        }
+
         private fun isSpoofAddress(displayName: String): Boolean {
             return displayName.contains("@") && SPOOF_ADDRESS_PATTERN.matcher(displayName).find()
         }
diff --git a/app/core/src/main/java/com/fsck/k9/mailstore/SpecialFolderUpdater.kt b/app/core/src/main/java/com/fsck/k9/mailstore/SpecialFolderUpdater.kt
index ec680c9758768064cd82a13544bf805e2e1a2aae..1caafeee9fce9084fbeb2b4ca9059d6b26f0eaa7 100644
--- a/app/core/src/main/java/com/fsck/k9/mailstore/SpecialFolderUpdater.kt
+++ b/app/core/src/main/java/com/fsck/k9/mailstore/SpecialFolderUpdater.kt
@@ -1,10 +1,10 @@
 package com.fsck.k9.mailstore
 
+import app.k9mail.core.common.mail.Protocols
 import com.fsck.k9.Account
 import com.fsck.k9.Account.SpecialFolderSelection
 import com.fsck.k9.Preferences
 import com.fsck.k9.mail.FolderClass
-import com.fsck.k9.preferences.Protocols
 
 /**
  * Updates special folders in [Account] if they are marked as [SpecialFolderSelection.AUTOMATIC] or if they are marked
diff --git a/app/core/src/main/java/com/fsck/k9/mailstore/SpecialLocalFoldersCreator.kt b/app/core/src/main/java/com/fsck/k9/mailstore/SpecialLocalFoldersCreator.kt
index 2b5f5298fb311db402fcc548d42e8aa39384f650..cdd19c7dde29c22a3063d71187b3deae0df0daa3 100644
--- a/app/core/src/main/java/com/fsck/k9/mailstore/SpecialLocalFoldersCreator.kt
+++ b/app/core/src/main/java/com/fsck/k9/mailstore/SpecialLocalFoldersCreator.kt
@@ -1,10 +1,10 @@
 package com.fsck.k9.mailstore
 
+import app.k9mail.core.common.mail.Protocols
 import com.fsck.k9.Account
 import com.fsck.k9.Account.SpecialFolderSelection
 import com.fsck.k9.Preferences
 import com.fsck.k9.mail.FolderType
-import com.fsck.k9.preferences.Protocols
 import timber.log.Timber
 
 class SpecialLocalFoldersCreator(
diff --git a/app/core/src/main/java/com/fsck/k9/message/IdentityHeaderBuilder.java b/app/core/src/main/java/com/fsck/k9/message/IdentityHeaderBuilder.java
index cb6c2c2344893a694604ba4f19025b07dbfc360a..33e957c018129acf3bb35ade1e316bf85f0132e3 100644
--- a/app/core/src/main/java/com/fsck/k9/message/IdentityHeaderBuilder.java
+++ b/app/core/src/main/java/com/fsck/k9/message/IdentityHeaderBuilder.java
@@ -1,6 +1,8 @@
 package com.fsck.k9.message;
 
 
+import java.util.Objects;
+
 import android.net.Uri;
 import android.net.Uri.Builder;
 
@@ -87,7 +89,7 @@ public class IdentityHeaderBuilder {
         }
 
         if (identityChanged) {
-            appendValue(IdentityField.NAME, identity.getName());
+            appendValue(IdentityField.NAME, Objects.requireNonNullElse(identity.getName(), ""));
             appendValue(IdentityField.EMAIL, identity.getEmail());
         }
 
diff --git a/app/core/src/main/java/com/fsck/k9/message/ReplyActionStrategy.kt b/app/core/src/main/java/com/fsck/k9/message/ReplyActionStrategy.kt
index 462d354deef27dbe90aa68123b27e7df3e905fab..403a8209e861fa2cf74e5db3bcc978e1c0952463 100644
--- a/app/core/src/main/java/com/fsck/k9/message/ReplyActionStrategy.kt
+++ b/app/core/src/main/java/com/fsck/k9/message/ReplyActionStrategy.kt
@@ -20,7 +20,7 @@ class ReplyActionStrategy(private val replyRoParser: ReplyToParser) {
                 ReplyActions(defaultAction = ReplyAction.REPLY)
             }
         } else {
-            ReplyActions(defaultAction = ReplyAction.REPLY_ALL, additionalActions = listOf(ReplyAction.REPLY))
+            ReplyActions(defaultAction = ReplyAction.REPLY, additionalActions = listOf(ReplyAction.REPLY_ALL))
         }
     }
 }
diff --git a/app/core/src/main/java/com/fsck/k9/message/html/UriMatcher.kt b/app/core/src/main/java/com/fsck/k9/message/html/UriMatcher.kt
index 891bb58524f0ccd9ad556cdf0a2b2e1538c330e7..b970b83c3bdf564728d1235a697cbb702b2132e9 100644
--- a/app/core/src/main/java/com/fsck/k9/message/html/UriMatcher.kt
+++ b/app/core/src/main/java/com/fsck/k9/message/html/UriMatcher.kt
@@ -31,4 +31,20 @@ object UriMatcher {
             parser.parseUri(text, startIndex)
         }.filterNotNull().toList()
     }
+
+    @Suppress("ReturnCount")
+    fun isValidUri(text: CharSequence): Boolean {
+        val matchResult = URI_SCHEME.matchAt(text, 0) ?: return false
+
+        val matchGroup = matchResult.groups[1]!!
+        if (matchGroup.range.first != 0) {
+            return false
+        }
+
+        val scheme = matchGroup.value.lowercase()
+        val parser = SUPPORTED_URIS[scheme] ?: throw AssertionError("Scheme not found: $scheme")
+        val uriMatch = parser.parseUri(text, startPos = 0) ?: return false
+
+        return uriMatch.startIndex == 0 && uriMatch.endIndex == text.length
+    }
 }
diff --git a/app/core/src/main/java/com/fsck/k9/notification/BackgroundWorkNotificationController.kt b/app/core/src/main/java/com/fsck/k9/notification/BackgroundWorkNotificationController.kt
new file mode 100644
index 0000000000000000000000000000000000000000..ad9b9d4683c4028e92f1da4f9cceb5e6629df7c0
--- /dev/null
+++ b/app/core/src/main/java/com/fsck/k9/notification/BackgroundWorkNotificationController.kt
@@ -0,0 +1,9 @@
+package com.fsck.k9.notification
+
+import android.app.Notification
+
+interface BackgroundWorkNotificationController {
+    val notificationId: Int
+
+    fun createNotification(text: String): Notification
+}
diff --git a/app/core/src/main/java/com/fsck/k9/notification/CoreKoinModule.kt b/app/core/src/main/java/com/fsck/k9/notification/CoreKoinModule.kt
index 7d6a80de8d18884897c16cdaedab65fff7d65c4a..967009d98901777fb908991e635a726d6675a80b 100644
--- a/app/core/src/main/java/com/fsck/k9/notification/CoreKoinModule.kt
+++ b/app/core/src/main/java/com/fsck/k9/notification/CoreKoinModule.kt
@@ -130,4 +130,11 @@ val coreNotificationModule = module {
             notificationConfigurationConverter = get(),
         )
     }
+    factory<BackgroundWorkNotificationController> {
+        RealBackgroundWorkNotificationController(
+            context = get(),
+            resourceProvider = get(),
+            notificationChannelManager = get(),
+        )
+    }
 }
diff --git a/app/core/src/main/java/com/fsck/k9/notification/NotificationChannelManager.kt b/app/core/src/main/java/com/fsck/k9/notification/NotificationChannelManager.kt
index f2a7c998cd7bfb065d7036c206d2dec1bc7f4376..b91c9665fe087bc794455a941a825ca34358fe40 100644
--- a/app/core/src/main/java/com/fsck/k9/notification/NotificationChannelManager.kt
+++ b/app/core/src/main/java/com/fsck/k9/notification/NotificationChannelManager.kt
@@ -23,6 +23,7 @@ class NotificationChannelManager(
     private val notificationLightDecoder: NotificationLightDecoder,
 ) {
     val pushChannelId = "push"
+    val miscellaneousChannelId = "misc"
 
     enum class ChannelType {
         MESSAGES, MISCELLANEOUS
@@ -50,6 +51,7 @@ class NotificationChannelManager(
     @RequiresApi(api = Build.VERSION_CODES.O)
     private fun addGeneralChannels() {
         notificationManager.createNotificationChannel(getChannelPush())
+        notificationManager.createNotificationChannel(getChannelMiscellaneous())
     }
 
     @RequiresApi(api = Build.VERSION_CODES.O)
@@ -101,6 +103,21 @@ class NotificationChannelManager(
         }
     }
 
+    @RequiresApi(api = Build.VERSION_CODES.O)
+    private fun getChannelMiscellaneous(): NotificationChannel {
+        val channelName = resourceProvider.miscellaneousChannelName
+        val channelDescription = resourceProvider.miscellaneousChannelDescription
+        val importance = NotificationManager.IMPORTANCE_LOW
+
+        return NotificationChannel(miscellaneousChannelId, channelName, importance).apply {
+            description = channelDescription
+            setShowBadge(false)
+            enableLights(false)
+            enableVibration(false)
+            setSound(null, null)
+        }
+    }
+
     @RequiresApi(api = Build.VERSION_CODES.O)
     private fun getChannelMessages(account: Account): NotificationChannel {
         val channelName = resourceProvider.messagesChannelName
diff --git a/app/core/src/main/java/com/fsck/k9/notification/NotificationIds.kt b/app/core/src/main/java/com/fsck/k9/notification/NotificationIds.kt
index d041c528fea3564871e3a1623623962de6057e56..10b4718193ffec92385d3d18ed9f87fc8ca0c66a 100644
--- a/app/core/src/main/java/com/fsck/k9/notification/NotificationIds.kt
+++ b/app/core/src/main/java/com/fsck/k9/notification/NotificationIds.kt
@@ -4,8 +4,9 @@ import com.fsck.k9.Account
 
 internal object NotificationIds {
     const val PUSH_NOTIFICATION_ID = 1
+    const val BACKGROUND_WORK_NOTIFICATION_ID = 2
 
-    private const val NUMBER_OF_GENERAL_NOTIFICATIONS = 1
+    private const val NUMBER_OF_GENERAL_NOTIFICATIONS = 2
     private const val OFFSET_SEND_FAILED_NOTIFICATION = 0
     private const val OFFSET_CERTIFICATE_ERROR_INCOMING = 1
     private const val OFFSET_CERTIFICATE_ERROR_OUTGOING = 2
diff --git a/app/core/src/main/java/com/fsck/k9/notification/NotificationResourceProvider.kt b/app/core/src/main/java/com/fsck/k9/notification/NotificationResourceProvider.kt
index ca15c49ae66aeb50af6d3499e936233e23df010c..91b97999f2f7a2effa21aa83d981ff273db9e02e 100644
--- a/app/core/src/main/java/com/fsck/k9/notification/NotificationResourceProvider.kt
+++ b/app/core/src/main/java/com/fsck/k9/notification/NotificationResourceProvider.kt
@@ -8,6 +8,7 @@ interface NotificationResourceProvider {
     val iconNewMail: Int
     val iconSendingMail: Int
     val iconCheckingMail: Int
+    val iconBackgroundWorkNotification: Int
     val wearIconMarkAsRead: Int
     val wearIconDelete: Int
     val wearIconArchive: Int
diff --git a/app/core/src/main/java/com/fsck/k9/notification/RealBackgroundWorkNotificationController.kt b/app/core/src/main/java/com/fsck/k9/notification/RealBackgroundWorkNotificationController.kt
new file mode 100644
index 0000000000000000000000000000000000000000..3852a8ae47f6a2c42b386bd482422bbc8ac61ffe
--- /dev/null
+++ b/app/core/src/main/java/com/fsck/k9/notification/RealBackgroundWorkNotificationController.kt
@@ -0,0 +1,28 @@
+package com.fsck.k9.notification
+
+import android.app.Notification
+import android.content.Context
+import androidx.core.app.NotificationCompat
+
+class RealBackgroundWorkNotificationController(
+    private val context: Context,
+    private val resourceProvider: NotificationResourceProvider,
+    private val notificationChannelManager: NotificationChannelManager,
+) : BackgroundWorkNotificationController {
+    override val notificationId = NotificationIds.BACKGROUND_WORK_NOTIFICATION_ID
+
+    override fun createNotification(text: String): Notification {
+        val notificationChannel = notificationChannelManager.miscellaneousChannelId
+
+        return NotificationCompat.Builder(context, notificationChannel)
+            .setSmallIcon(resourceProvider.iconBackgroundWorkNotification)
+            .setContentTitle(text)
+            .setOngoing(true)
+            .setNotificationSilent()
+            .setPriority(NotificationCompat.PRIORITY_MIN)
+            .setBadgeIconType(NotificationCompat.BADGE_ICON_NONE)
+            .setLocalOnly(true)
+            .setShowWhen(false)
+            .build()
+    }
+}
diff --git a/app/core/src/main/java/com/fsck/k9/oauth/OAuthConfigurationProvider.kt b/app/core/src/main/java/com/fsck/k9/oauth/OAuthConfigurationProvider.kt
deleted file mode 100644
index b9cd706090dc8ec0e703ac9895673195d50680c7..0000000000000000000000000000000000000000
--- a/app/core/src/main/java/com/fsck/k9/oauth/OAuthConfigurationProvider.kt
+++ /dev/null
@@ -1,22 +0,0 @@
-package com.fsck.k9.oauth
-
-class OAuthConfigurationProvider(
-    private val configurations: Map<List<String>, OAuthConfiguration>,
-    private val googleConfiguration: OAuthConfiguration,
-) {
-    private val hostnameMapping: Map<String, OAuthConfiguration> = buildMap {
-        for ((hostnames, configuration) in configurations) {
-            for (hostname in hostnames) {
-                put(hostname.lowercase(), configuration)
-            }
-        }
-    }
-
-    fun getConfiguration(hostname: String): OAuthConfiguration? {
-        return hostnameMapping[hostname.lowercase()]
-    }
-
-    fun isGoogle(hostname: String): Boolean {
-        return getConfiguration(hostname) == googleConfiguration
-    }
-}
diff --git a/app/core/src/main/java/com/fsck/k9/preferences/ServerTypeConverter.kt b/app/core/src/main/java/com/fsck/k9/preferences/ServerTypeConverter.kt
index 9889649030ba31783f0e8ad7e242a8f2665c9baa..d73b34f4644c1518a04998fe7825affeecaa8766 100644
--- a/app/core/src/main/java/com/fsck/k9/preferences/ServerTypeConverter.kt
+++ b/app/core/src/main/java/com/fsck/k9/preferences/ServerTypeConverter.kt
@@ -1,5 +1,7 @@
 package com.fsck.k9.preferences
 
+import app.k9mail.core.common.mail.Protocols
+
 object ServerTypeConverter {
     @JvmStatic
     fun toServerSettingsType(exportType: String): String = exportType.lowercase()
diff --git a/app/core/src/main/java/com/fsck/k9/preferences/SettingsExporter.kt b/app/core/src/main/java/com/fsck/k9/preferences/SettingsExporter.kt
index 2f32b1885455f86cbdaa4619ba4debccc964695a..3ac742a8d29a7bac627ee5dee1bb9507444d5b70 100644
--- a/app/core/src/main/java/com/fsck/k9/preferences/SettingsExporter.kt
+++ b/app/core/src/main/java/com/fsck/k9/preferences/SettingsExporter.kt
@@ -206,7 +206,7 @@ class SettingsExporter(
             if (hasThirdPart) {
                 val secondPart = keyPart.substring(0, indexOfLastDot)
                 val thirdPart = keyPart.substring(indexOfLastDot + 1)
-                if (secondPart == IDENTITY_DESCRIPTION_KEY) {
+                if (secondPart == IDENTITY_EMAIL_KEY) {
                     // This is an identity key. Save identity index for later...
                     thirdPart.toIntOrNull()?.let {
                         identities.add(it)
diff --git a/app/core/src/main/java/com/fsck/k9/preferences/SettingsImporter.java b/app/core/src/main/java/com/fsck/k9/preferences/SettingsImporter.java
index 88e4a5a298dca3037ca25889dcb6dfd370495ed4..3d9b26170445dccade571c7ace6325fc2bb93480 100644
--- a/app/core/src/main/java/com/fsck/k9/preferences/SettingsImporter.java
+++ b/app/core/src/main/java/com/fsck/k9/preferences/SettingsImporter.java
@@ -533,19 +533,6 @@ public class SettingsImporter {
                 nextIdentityIndex++;
             }
 
-            String identityDescription = (identity.description == null) ? "Imported" : identity.description;
-            if (isIdentityDescriptionUsed(identityDescription, existingIdentities)) {
-                // Identity description is already in use. So generate a new one by appending
-                // " (x)", where x is the first number >= 1 that results in an unused identity
-                // description.
-                for (int i = 1; i <= existingIdentities.size(); i++) {
-                    identityDescription = identity.description + " (" + i + ")";
-                    if (!isIdentityDescriptionUsed(identityDescription, existingIdentities)) {
-                        break;
-                    }
-                }
-            }
-
             String identitySuffix = "." + writeIdentityIndex;
 
             // Write name used in identity
@@ -561,8 +548,10 @@ public class SettingsImporter {
             putString(editor, accountKeyPrefix + AccountPreferenceSerializer.IDENTITY_EMAIL_KEY + identitySuffix, identity.email);
 
             // Write identity description
-            putString(editor, accountKeyPrefix + AccountPreferenceSerializer.IDENTITY_DESCRIPTION_KEY + identitySuffix,
-                    identityDescription);
+            if (identity.description != null) {
+                putString(editor, accountKeyPrefix + AccountPreferenceSerializer.IDENTITY_DESCRIPTION_KEY + identitySuffix,
+                        identity.description);
+            }
 
             if (identity.settings != null) {
                 // Validate identity settings
@@ -610,15 +599,6 @@ public class SettingsImporter {
         return false;
     }
 
-    private static boolean isIdentityDescriptionUsed(String description, List<Identity> identities) {
-        for (Identity identity : identities) {
-            if (identity.getDescription().equals(description)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
     private static int findIdentity(ImportedIdentity identity, List<Identity> identities) {
         for (int i = 0; i < identities.size(); i++) {
             Identity existingIdentity = identities.get(i);
diff --git a/app/core/src/main/java/com/fsck/k9/setup/EeloAccountHelper.kt b/app/core/src/main/java/com/fsck/k9/setup/EeloAccountHelper.kt
index e3d02b2d9d5b35fdefe42b2312775b2a7e2c7dac..2ff0157fdc57b6a537b5f0c64c2fc5327f3c0c93 100644
--- a/app/core/src/main/java/com/fsck/k9/setup/EeloAccountHelper.kt
+++ b/app/core/src/main/java/com/fsck/k9/setup/EeloAccountHelper.kt
@@ -19,6 +19,7 @@ package com.fsck.k9.setup
 import android.content.Context
 import com.fsck.k9.Account
 import com.fsck.k9.mail.AuthType
+import com.fsck.k9.mail.oauth.AuthStateStorage
 import com.fsck.k9.preferences.AccountManager
 import timber.log.Timber
 import android.accounts.Account as OsAccount
@@ -58,16 +59,48 @@ object EeloAccountHelper {
         return result
     }
 
+    fun updateOAuthState(context: Context, authStateStorage: AuthStateStorage): Boolean {
+        // check params
+        if (authStateStorage.getEmail().isNullOrBlank()) {
+            Timber.w("updating OAuthState failed, email is null")
+            return false
+        }
+
+        val osAccountManager = OsAccountManager.get(context)
+
+        var result = false
+        AccountManagerConstants.OPENID_ACCOUNT_TYPES.forEach {
+            val openIdAccount =
+                retrieveOpenIdAccountFromAccountManager(osAccountManager, it, authStateStorage.getEmail())
+            if (openIdAccount != null) {
+                updateOAuthState(authStateStorage, openIdAccount, osAccountManager)
+                result = true
+                return@forEach
+            }
+        }
+
+        return result
+    }
+
     private fun updateOAuthState(
         account: Account,
         osAccountManager: android.accounts.AccountManager,
-        googleAccount: android.accounts.Account?,
+        openIdAccount: android.accounts.Account?,
         accountManager: AccountManager,
     ) {
-        account.oAuthState = osAccountManager.getUserData(googleAccount, AccountManagerConstants.KEY_AUTH_STATE)
+        account.oAuthState = osAccountManager.getUserData(openIdAccount, AccountManagerConstants.KEY_AUTH_STATE)
         accountManager.saveAccount(account)
     }
 
+    private fun updateOAuthState(
+        authStateStorage: AuthStateStorage,
+        openIdAccount: android.accounts.Account?,
+        osAccountManager: android.accounts.AccountManager,
+    ) {
+        val authState = osAccountManager.getUserData(openIdAccount, AccountManagerConstants.KEY_AUTH_STATE)
+        authStateStorage.updateAuthorizationState(authorizationState = authState)
+    }
+
     // If token is updated by mail, also update the accountManager
     fun updateAccountInAccountManager(
         context: Context?,
diff --git a/app/core/src/main/java/com/fsck/k9/setup/ServerNameSuggester.kt b/app/core/src/main/java/com/fsck/k9/setup/ServerNameSuggester.kt
deleted file mode 100644
index 1731aa4d9be3d11b06becf9742fb445d34ea8af1..0000000000000000000000000000000000000000
--- a/app/core/src/main/java/com/fsck/k9/setup/ServerNameSuggester.kt
+++ /dev/null
@@ -1,12 +0,0 @@
-package com.fsck.k9.setup
-
-import com.fsck.k9.preferences.Protocols
-
-class ServerNameSuggester {
-    fun suggestServerName(serverType: String, domainPart: String): String = when (serverType) {
-        Protocols.IMAP -> "imap.$domainPart"
-        Protocols.SMTP -> "smtp.$domainPart"
-        Protocols.POP3 -> "pop3.$domainPart"
-        else -> throw AssertionError("Missed case: $serverType")
-    }
-}
diff --git a/app/core/src/test/java/com/fsck/k9/EmailAddressValidatorTest.kt b/app/core/src/test/java/com/fsck/k9/EmailAddressValidatorTest.kt
index f839dec1de318805f7dc8a6af605a8a03060ff27..1e03aaeed62d11663914ed801bb43be55551b0b5 100644
--- a/app/core/src/test/java/com/fsck/k9/EmailAddressValidatorTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/EmailAddressValidatorTest.kt
@@ -1,36 +1,46 @@
 package com.fsck.k9
 
-import org.junit.Assert
+import assertk.assertThat
+import assertk.assertions.isFalse
+import assertk.assertions.isTrue
 import org.junit.Test
 
 class EmailAddressValidatorTest {
+    private val validator = EmailAddressValidator()
 
     @Test
     fun testEmailValidation() {
         // Most of the tests based on https://en.wikipedia.org/wiki/Email_address#Examples
-        val validator = EmailAddressValidator()
-        Assert.assertTrue(validator.isValidAddressOnly("simple@example.com"))
-        Assert.assertTrue(validator.isValidAddressOnly("very.common@example.com"))
-        Assert.assertTrue(validator.isValidAddressOnly("disposable.style.email.with+symbol@example.com"))
-        Assert.assertTrue(validator.isValidAddressOnly("other.email-with-hyphen@example.com"))
-        Assert.assertTrue(validator.isValidAddressOnly("fully-qualified-domain@example.com"))
-        Assert.assertTrue(validator.isValidAddressOnly("user.name+tag+sorting@example.com"))
-        Assert.assertTrue(validator.isValidAddressOnly("example-indeed@strange-example.com"))
-        Assert.assertTrue(validator.isValidAddressOnly("example-indeed@strange_example.com"))
-        Assert.assertTrue(validator.isValidAddressOnly("example@1.com"))
-        Assert.assertTrue(validator.isValidAddressOnly("admin@mailserver1"))
-        Assert.assertTrue(validator.isValidAddressOnly("user@localserver"))
-        Assert.assertTrue(validator.isValidAddressOnly("\"very.(),:;<>[]\\\".VERY.\\\"very@\\\\ \\\"very\\\".unusual\"@strange.example.com"))
-        Assert.assertTrue(validator.isValidAddressOnly("\"()<>[]:,;@\\\\\\\"!#$%&'-/=?^_`{}| ~.a\"@example.org"))
-        Assert.assertTrue(validator.isValidAddressOnly("\" \"@example.org"))
-        Assert.assertTrue(validator.isValidAddressOnly("x@example.com"))
+        assertValidAddress("simple@example.com")
+        assertValidAddress("very.common@example.com")
+        assertValidAddress("disposable.style.email.with+symbol@example.com")
+        assertValidAddress("other.email-with-hyphen@example.com")
+        assertValidAddress("fully-qualified-domain@example.com")
+        assertValidAddress("user.name+tag+sorting@example.com")
+        assertValidAddress("example-indeed@strange-example.com")
+        assertValidAddress("example-indeed@strange_example.com")
+        assertValidAddress("example@1.com")
+        assertValidAddress("admin@mailserver1")
+        assertValidAddress("user@localserver")
+        assertValidAddress("\"very.(),:;<>[]\\\".VERY.\\\"very@\\\\ \\\"very\\\".unusual\"@strange.example.com")
+        assertValidAddress("\"()<>[]:,;@\\\\\\\"!#$%&'-/=?^_`{}| ~.a\"@example.org")
+        assertValidAddress("\" \"@example.org")
+        assertValidAddress("x@example.com")
 
-        Assert.assertFalse(validator.isValidAddressOnly("Abc.example.com"))
-        Assert.assertFalse(validator.isValidAddressOnly("\"not\"right@example.com"))
-        Assert.assertFalse(validator.isValidAddressOnly("john.doe@example..com"))
-        Assert.assertFalse(validator.isValidAddressOnly("example@c.2"))
-        Assert.assertFalse(validator.isValidAddressOnly("this\\ still\\\"not\\\\allowed@example.com"))
-        Assert.assertFalse(validator.isValidAddressOnly("john..doe@example.com"))
-        Assert.assertFalse(validator.isValidAddressOnly("invalidperiod.@example.com"))
+        assertInvalidAddress("Abc.example.com")
+        assertInvalidAddress("\"not\"right@example.com")
+        assertInvalidAddress("john.doe@example..com")
+        assertInvalidAddress("example@c.2")
+        assertInvalidAddress("this\\ still\\\"not\\\\allowed@example.com")
+        assertInvalidAddress("john..doe@example.com")
+        assertInvalidAddress("invalidperiod.@example.com")
+    }
+
+    private fun assertValidAddress(input: String) {
+        assertThat(input).transform { validator.isValidAddressOnly(it) }.isTrue()
+    }
+
+    private fun assertInvalidAddress(input: String) {
+        assertThat(input).transform { validator.isValidAddressOnly(it) }.isFalse()
     }
 }
diff --git a/app/core/src/test/java/com/fsck/k9/QuietTimeCheckerTest.kt b/app/core/src/test/java/com/fsck/k9/QuietTimeCheckerTest.kt
index 854f3dc2f8a5019a8e994b5f4f0b1ae8093987b0..d664e60ff1989f686ee709805b35b8a7200d74aa 100644
--- a/app/core/src/test/java/com/fsck/k9/QuietTimeCheckerTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/QuietTimeCheckerTest.kt
@@ -1,10 +1,11 @@
 package com.fsck.k9
 
 import app.k9mail.core.testing.TestClock
+import assertk.assertThat
+import assertk.assertions.isFalse
+import assertk.assertions.isTrue
 import java.util.Calendar
 import kotlinx.datetime.Instant
-import org.junit.Assert.assertFalse
-import org.junit.Assert.assertTrue
 import org.junit.Test
 
 class QuietTimeCheckerTest {
@@ -15,7 +16,7 @@ class QuietTimeCheckerTest {
         setClockTo("02:00")
         val quietTimeChecker = QuietTimeChecker(clock, "22:30", "06:45")
 
-        assertTrue(quietTimeChecker.isQuietTime)
+        assertThat(quietTimeChecker.isQuietTime).isTrue()
     }
 
     @Test
@@ -23,7 +24,7 @@ class QuietTimeCheckerTest {
         setClockTo("10:00")
         val quietTimeChecker = QuietTimeChecker(clock, "22:30", "06:45")
 
-        assertFalse(quietTimeChecker.isQuietTime)
+        assertThat(quietTimeChecker.isQuietTime).isFalse()
     }
 
     @Test
@@ -31,7 +32,7 @@ class QuietTimeCheckerTest {
         setClockTo("23:00")
         val quietTimeChecker = QuietTimeChecker(clock, "22:30", "06:45")
 
-        assertTrue(quietTimeChecker.isQuietTime)
+        assertThat(quietTimeChecker.isQuietTime).isTrue()
     }
 
     @Test
@@ -39,7 +40,7 @@ class QuietTimeCheckerTest {
         setClockTo("22:30")
         val quietTimeChecker = QuietTimeChecker(clock, "22:30", "06:45")
 
-        assertTrue(quietTimeChecker.isQuietTime)
+        assertThat(quietTimeChecker.isQuietTime).isTrue()
     }
 
     @Test
@@ -47,7 +48,7 @@ class QuietTimeCheckerTest {
         setClockTo("06:45")
         val quietTimeChecker = QuietTimeChecker(clock, "22:30", "06:45")
 
-        assertTrue(quietTimeChecker.isQuietTime)
+        assertThat(quietTimeChecker.isQuietTime).isTrue()
     }
 
     @Test
@@ -55,7 +56,7 @@ class QuietTimeCheckerTest {
         setClockTo("02:00")
         val quietTimeChecker = QuietTimeChecker(clock, "09:00", "17:00")
 
-        assertFalse(quietTimeChecker.isQuietTime)
+        assertThat(quietTimeChecker.isQuietTime).isFalse()
     }
 
     @Test
@@ -63,7 +64,7 @@ class QuietTimeCheckerTest {
         setClockTo("10:00")
         val quietTimeChecker = QuietTimeChecker(clock, "09:00", "17:00")
 
-        assertTrue(quietTimeChecker.isQuietTime)
+        assertThat(quietTimeChecker.isQuietTime).isTrue()
     }
 
     @Test
@@ -71,7 +72,7 @@ class QuietTimeCheckerTest {
         setClockTo("20:00")
         val quietTimeChecker = QuietTimeChecker(clock, "09:00", "17:00")
 
-        assertFalse(quietTimeChecker.isQuietTime)
+        assertThat(quietTimeChecker.isQuietTime).isFalse()
     }
 
     @Test
@@ -79,7 +80,7 @@ class QuietTimeCheckerTest {
         setClockTo("09:00")
         val quietTimeChecker = QuietTimeChecker(clock, "09:00", "17:00")
 
-        assertTrue(quietTimeChecker.isQuietTime)
+        assertThat(quietTimeChecker.isQuietTime).isTrue()
     }
 
     @Test
@@ -87,7 +88,7 @@ class QuietTimeCheckerTest {
         setClockTo("17:00")
         val quietTimeChecker = QuietTimeChecker(clock, "09:00", "17:00")
 
-        assertTrue(quietTimeChecker.isQuietTime)
+        assertThat(quietTimeChecker.isQuietTime).isTrue()
     }
 
     @Test
@@ -95,7 +96,7 @@ class QuietTimeCheckerTest {
         setClockTo("10:00")
         val quietTimeChecker = QuietTimeChecker(clock, "06:00", "06:00")
 
-        assertFalse(quietTimeChecker.isQuietTime)
+        assertThat(quietTimeChecker.isQuietTime).isFalse()
     }
 
     @Test
@@ -103,7 +104,7 @@ class QuietTimeCheckerTest {
         setClockTo("06:00")
         val quietTimeChecker = QuietTimeChecker(clock, "06:00", "06:00")
 
-        assertFalse(quietTimeChecker.isQuietTime)
+        assertThat(quietTimeChecker.isQuietTime).isFalse()
     }
 
     private fun setClockTo(time: String) {
diff --git a/app/core/src/test/java/com/fsck/k9/ServerSettingsSerializerTest.kt b/app/core/src/test/java/com/fsck/k9/ServerSettingsSerializerTest.kt
index 21666945b40567bfde24ab7270a0c41f2f2df772..d2e97ea3c7249ac66b85a9329ae06f08d32e9a27 100644
--- a/app/core/src/test/java/com/fsck/k9/ServerSettingsSerializerTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/ServerSettingsSerializerTest.kt
@@ -1,9 +1,9 @@
 package com.fsck.k9
 
+import assertk.assertFailure
 import assertk.assertThat
 import assertk.assertions.hasMessage
 import assertk.assertions.isEqualTo
-import assertk.assertions.isFailure
 import assertk.assertions.isInstanceOf
 import com.fsck.k9.mail.AuthType
 import com.fsck.k9.mail.ConnectionSecurity
@@ -67,10 +67,9 @@ class ServerSettingsSerializerTest {
             }
         """.trimIndent()
 
-        assertThat {
+        assertFailure {
             serverSettingsSerializer.deserialize(json)
-        }.isFailure()
-            .isInstanceOf(IllegalArgumentException::class)
+        }.isInstanceOf<IllegalArgumentException>()
             .hasMessage("'type' must not be missing")
     }
 }
diff --git a/app/core/src/test/java/com/fsck/k9/autocrypt/AutocryptDraftStateHeaderParserTest.kt b/app/core/src/test/java/com/fsck/k9/autocrypt/AutocryptDraftStateHeaderParserTest.kt
index c9b12cb37a30d95616204e3052ddcf8c3da5770d..4d30ff7543a378151c8f34995e178de1fdef1843 100644
--- a/app/core/src/test/java/com/fsck/k9/autocrypt/AutocryptDraftStateHeaderParserTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/autocrypt/AutocryptDraftStateHeaderParserTest.kt
@@ -1,12 +1,12 @@
 package com.fsck.k9.autocrypt
 
+import app.k9mail.core.android.testing.RobolectricTest
 import assertk.assertThat
 import assertk.assertions.isEqualTo
 import assertk.assertions.isFalse
 import assertk.assertions.isNotNull
 import assertk.assertions.isNull
 import assertk.assertions.isTrue
-import com.fsck.k9.RobolectricTest
 import org.junit.Test
 
 class AutocryptDraftStateHeaderParserTest : RobolectricTest() {
diff --git a/app/core/src/test/java/com/fsck/k9/autocrypt/AutocryptGossipHeaderParserTest.kt b/app/core/src/test/java/com/fsck/k9/autocrypt/AutocryptGossipHeaderParserTest.kt
index 40ccbf523bff4ca36332d2a83946912202196488..59f3fb3461e704decf94694fbec275ff798fbbdb 100644
--- a/app/core/src/test/java/com/fsck/k9/autocrypt/AutocryptGossipHeaderParserTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/autocrypt/AutocryptGossipHeaderParserTest.kt
@@ -1,12 +1,16 @@
 package com.fsck.k9.autocrypt
 
+import assertk.all
+import assertk.assertThat
+import assertk.assertions.containsExactly
+import assertk.assertions.extracting
+import assertk.assertions.index
+import assertk.assertions.isEqualTo
+import assertk.assertions.isNotNull
+import assertk.assertions.isNull
 import com.fsck.k9.mail.crlf
 import com.fsck.k9.mail.filter.Base64
 import com.fsck.k9.mailstore.MimePartStreamParser
-import org.junit.Assert.assertArrayEquals
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNotNull
-import org.junit.Assert.assertNull
 import org.junit.Test
 
 class AutocryptGossipHeaderParserTest {
@@ -56,20 +60,24 @@ class AutocryptGossipHeaderParserTest {
         val gossipPart = MimePartStreamParser.parse(null, GOSSIP_PART.byteInputStream())
         val allAutocryptGossipHeaders = autocryptGossipHeaderParser.getAllAutocryptGossipHeaders(gossipPart)
 
-        assertEquals("text/plain", gossipPart.mimeType)
-        assertEquals(2, allAutocryptGossipHeaders.size)
-        assertEquals("bob@autocrypt.example", allAutocryptGossipHeaders[0].addr)
-        assertEquals("carol@autocrypt.example", allAutocryptGossipHeaders[1].addr)
-        assertArrayEquals(GOSSIP_DATA_BOB, allAutocryptGossipHeaders[0].keyData)
+        assertThat(gossipPart.mimeType).isEqualTo("text/plain")
+        assertThat(allAutocryptGossipHeaders).all {
+            extracting { it.addr }.containsExactly(
+                "bob@autocrypt.example",
+                "carol@autocrypt.example",
+            )
+            index(0).transform { it.keyData }.isEqualTo(GOSSIP_DATA_BOB)
+        }
     }
 
     @Test
     fun parseString() {
         val gossipHeader = autocryptGossipHeaderParser.parseAutocryptGossipHeader(GOSSIP_HEADER_BOB)
 
-        gossipHeader!!
-        assertArrayEquals(GOSSIP_DATA_BOB, gossipHeader.keyData)
-        assertEquals(GOSSIP_RAW_HEADER_BOB, gossipHeader.toRawHeaderString())
+        assertThat(gossipHeader).isNotNull().all {
+            transform { it.keyData }.isEqualTo(GOSSIP_DATA_BOB)
+            transform { it.toRawHeaderString() }.isEqualTo(GOSSIP_RAW_HEADER_BOB)
+        }
     }
 
     @Test
@@ -78,7 +86,7 @@ class AutocryptGossipHeaderParserTest {
             "addr=CDEF",
         )
 
-        assertNull(gossipHeader)
+        assertThat(gossipHeader).isNull()
     }
 
     @Test
@@ -87,7 +95,7 @@ class AutocryptGossipHeaderParserTest {
             "addr=bawb; somecritical=value; keydata=aGk",
         )
 
-        assertNull(gossipHeader)
+        assertThat(gossipHeader).isNull()
     }
 
     @Test
@@ -96,7 +104,7 @@ class AutocryptGossipHeaderParserTest {
             "addr=bawb; _somenoncritical=value; keydata=aGk",
         )
 
-        assertNotNull(gossipHeader)
+        assertThat(gossipHeader).isNotNull()
     }
 
     @Test
@@ -105,6 +113,6 @@ class AutocryptGossipHeaderParserTest {
             "addr=bawb; _somenoncritical=value; keydata=X",
         )
 
-        assertNull(gossipHeader)
+        assertThat(gossipHeader).isNull()
     }
 }
diff --git a/app/core/src/test/java/com/fsck/k9/autocrypt/AutocryptHeaderParserTest.java b/app/core/src/test/java/com/fsck/k9/autocrypt/AutocryptHeaderParserTest.java
index 56f45561bf89feccff3af8bfee7de388495d47ee..38d0b95a5dbff756018ddeb04a3fe3e2ca5fe053 100644
--- a/app/core/src/test/java/com/fsck/k9/autocrypt/AutocryptHeaderParserTest.java
+++ b/app/core/src/test/java/com/fsck/k9/autocrypt/AutocryptHeaderParserTest.java
@@ -5,7 +5,7 @@ import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;
 
-import com.fsck.k9.RobolectricTest;
+import app.k9mail.core.android.testing.RobolectricTest;
 import com.fsck.k9.mail.MessagingException;
 import com.fsck.k9.mail.internet.BinaryTempFileBody;
 import com.fsck.k9.mail.internet.MimeMessage;
diff --git a/app/core/src/test/java/com/fsck/k9/controller/MessagingControllerTest.java b/app/core/src/test/java/com/fsck/k9/controller/MessagingControllerTest.java
index 3dbb7d380f26aedfe1e67b2fc4b98a49ef45a0ab..d8c8ad7c737663654c16d646d6039bf584ca1021 100644
--- a/app/core/src/test/java/com/fsck/k9/controller/MessagingControllerTest.java
+++ b/app/core/src/test/java/com/fsck/k9/controller/MessagingControllerTest.java
@@ -33,7 +33,7 @@ import com.fsck.k9.mailstore.SendState;
 import com.fsck.k9.mailstore.SpecialLocalFoldersCreator;
 import com.fsck.k9.notification.NotificationController;
 import com.fsck.k9.notification.NotificationStrategy;
-import com.fsck.k9.preferences.Protocols;
+import app.k9mail.core.common.mail.Protocols;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
diff --git a/app/core/src/test/java/com/fsck/k9/crypto/OpenPgpApiHelperTest.kt b/app/core/src/test/java/com/fsck/k9/crypto/OpenPgpApiHelperTest.kt
index b55959e849c6768c56d2beeae7fa0d4412da3a1f..0d54de0edf7c914822455afb824644c41ce129e9 100644
--- a/app/core/src/test/java/com/fsck/k9/crypto/OpenPgpApiHelperTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/crypto/OpenPgpApiHelperTest.kt
@@ -1,7 +1,8 @@
 package com.fsck.k9.crypto
 
+import assertk.assertThat
+import assertk.assertions.isEqualTo
 import com.fsck.k9.Identity
-import org.junit.Assert.assertEquals
 import org.junit.Test
 
 class OpenPgpApiHelperTest {
@@ -15,7 +16,7 @@ class OpenPgpApiHelperTest {
 
         val result = OpenPgpApiHelper.buildUserId(identity)
 
-        assertEquals("Name <user@domain.com>", result)
+        assertThat(result).isEqualTo("Name <user@domain.com>")
     }
 
     @Test
@@ -26,6 +27,6 @@ class OpenPgpApiHelperTest {
 
         val result = OpenPgpApiHelper.buildUserId(identity)
 
-        assertEquals("<user@domain.com>", result)
+        assertThat(result).isEqualTo("<user@domain.com>")
     }
 }
diff --git a/app/core/src/test/java/com/fsck/k9/helper/IdentityHelperTest.kt b/app/core/src/test/java/com/fsck/k9/helper/IdentityHelperTest.kt
index f6a3e0feb7023a15e8ba59f7dfed93375929301d..aade6b77cc70292c901897963cf79573455eaa46 100644
--- a/app/core/src/test/java/com/fsck/k9/helper/IdentityHelperTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/helper/IdentityHelperTest.kt
@@ -1,10 +1,10 @@
 package com.fsck.k9.helper
 
+import app.k9mail.core.android.testing.RobolectricTest
 import assertk.assertThat
 import assertk.assertions.isEqualTo
 import com.fsck.k9.Account
 import com.fsck.k9.Identity
-import com.fsck.k9.RobolectricTest
 import com.fsck.k9.mail.Address
 import com.fsck.k9.mail.Message
 import com.fsck.k9.mail.Message.RecipientType
diff --git a/app/core/src/test/java/com/fsck/k9/helper/ListHeadersTest.java b/app/core/src/test/java/com/fsck/k9/helper/ListHeadersTest.java
index 1f0fdfcd6eca00f4267be2412ba7bc37222e92f3..f2ca0b835fd8615f9c6a70faf69f6d99c8e6a117 100644
--- a/app/core/src/test/java/com/fsck/k9/helper/ListHeadersTest.java
+++ b/app/core/src/test/java/com/fsck/k9/helper/ListHeadersTest.java
@@ -1,7 +1,6 @@
 package com.fsck.k9.helper;
 
-
-import com.fsck.k9.RobolectricTest;
+import app.k9mail.core.android.testing.RobolectricTest;
 import com.fsck.k9.mail.Address;
 import com.fsck.k9.mail.Message;
 import com.fsck.k9.mail.internet.MimeMessage;
@@ -10,7 +9,6 @@ import org.junit.Test;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 
-
 public class ListHeadersTest extends RobolectricTest {
     private static final String[] TEST_EMAIL_ADDRESSES = new String[] {
             "prettyandsimple@example.com",
diff --git a/app/core/src/test/java/com/fsck/k9/helper/ListUnsubscribeHelperTest.kt b/app/core/src/test/java/com/fsck/k9/helper/ListUnsubscribeHelperTest.kt
index 6b8419d2511d54e5b8759b267719bd9d50c61d1f..bfef14f10419c97e58fd992aa3ffff2037702b44 100644
--- a/app/core/src/test/java/com/fsck/k9/helper/ListUnsubscribeHelperTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/helper/ListUnsubscribeHelperTest.kt
@@ -1,11 +1,11 @@
 package com.fsck.k9.helper
 
 import androidx.core.net.toUri
+import app.k9mail.core.android.testing.RobolectricTest
 import assertk.assertThat
 import assertk.assertions.isEqualTo
-import com.fsck.k9.RobolectricTest
+import assertk.assertions.isNull
 import com.fsck.k9.mail.internet.MimeMessage
-import kotlin.test.assertNull
 import org.junit.Test
 
 class ListUnsubscribeHelperTest : RobolectricTest() {
@@ -60,7 +60,7 @@ class ListUnsubscribeHelperTest : RobolectricTest() {
             "<http://example.com/unsubscribe>",
         )
         val result = ListUnsubscribeHelper.getPreferredListUnsubscribeUri(message)
-        assertNull(result)
+        assertThat(result).isNull()
     }
 
     @Test
@@ -78,14 +78,14 @@ class ListUnsubscribeHelperTest : RobolectricTest() {
             "",
         )
         val result = ListUnsubscribeHelper.getPreferredListUnsubscribeUri(message)
-        assertNull(result)
+        assertThat(result).isNull()
     }
 
     @Test
     fun `get list unsubscribe url - should ignore missing header`() {
         val message = MimeMessage()
         val result = ListUnsubscribeHelper.getPreferredListUnsubscribeUri(message)
-        assertNull(result)
+        assertThat(result).isNull()
     }
 
     private fun buildMimeMessageWithListUnsubscribeValue(value: String): MimeMessage {
diff --git a/app/core/src/test/java/com/fsck/k9/helper/MailToTest.java b/app/core/src/test/java/com/fsck/k9/helper/MailToTest.java
index d388d4136d5716ce093e802f3e88612f90617ef4..e5eebc6b209b9650a6bf4de395bb05ba1212403b 100644
--- a/app/core/src/test/java/com/fsck/k9/helper/MailToTest.java
+++ b/app/core/src/test/java/com/fsck/k9/helper/MailToTest.java
@@ -7,7 +7,7 @@ import java.util.List;
 
 import android.net.Uri;
 
-import com.fsck.k9.RobolectricTest;
+import app.k9mail.core.android.testing.RobolectricTest;
 import com.fsck.k9.helper.MailTo.CaseInsensitiveParamWrapper;
 import com.fsck.k9.mail.Address;
 import org.junit.Rule;
diff --git a/app/core/src/test/java/com/fsck/k9/helper/MessageHelperTest.kt b/app/core/src/test/java/com/fsck/k9/helper/MessageHelperTest.kt
index 2f31e774fbde4f61b8fb3ac4fe7fb414ad36d29c..fc7d3a982cf12fa3d7d1f8cfa671998893af8e7b 100644
--- a/app/core/src/test/java/com/fsck/k9/helper/MessageHelperTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/helper/MessageHelperTest.kt
@@ -4,11 +4,12 @@ import android.graphics.Color
 import android.text.SpannableString
 import app.k9mail.core.android.common.contact.Contact
 import app.k9mail.core.android.common.contact.ContactRepository
+import app.k9mail.core.android.testing.RobolectricTest
 import app.k9mail.core.common.mail.EmailAddress
+import app.k9mail.core.common.mail.toEmailAddressOrThrow
 import assertk.assertThat
 import assertk.assertions.isEqualTo
 import assertk.assertions.isInstanceOf
-import com.fsck.k9.RobolectricTest
 import com.fsck.k9.helper.MessageHelper.Companion.toFriendly
 import com.fsck.k9.mail.Address
 import org.junit.Test
@@ -60,7 +61,7 @@ class MessageHelperTest : RobolectricTest() {
             changeContactNameColor = true,
             contactNameColor = Color.RED,
         )
-        assertThat(friendly).isInstanceOf(SpannableString::class.java)
+        assertThat(friendly).isInstanceOf<SpannableString>()
         assertThat(friendly.toString()).isEqualTo("Tim Testor")
     }
 
@@ -142,6 +143,6 @@ class MessageHelperTest : RobolectricTest() {
     }
 
     private companion object {
-        val EMAIL_ADDRESS = EmailAddress("test@testor.com")
+        val EMAIL_ADDRESS = "test@testor.com".toEmailAddressOrThrow()
     }
 }
diff --git a/app/core/src/test/java/com/fsck/k9/helper/ReplyToParserTest.java b/app/core/src/test/java/com/fsck/k9/helper/ReplyToParserTest.java
index 6093ed15fdc6b0536d8ec36a0ae8b41e00513399..507bb35e06e263d2b02fb2ee7ccc1c43182b5040 100644
--- a/app/core/src/test/java/com/fsck/k9/helper/ReplyToParserTest.java
+++ b/app/core/src/test/java/com/fsck/k9/helper/ReplyToParserTest.java
@@ -1,11 +1,10 @@
 package com.fsck.k9.helper;
 
-
 import java.lang.reflect.Array;
 import java.util.ArrayList;
 
+import app.k9mail.core.android.testing.RobolectricTest;
 import com.fsck.k9.Account;
-import com.fsck.k9.RobolectricTest;
 import com.fsck.k9.helper.ReplyToParser.ReplyToAddresses;
 import com.fsck.k9.mail.Address;
 import com.fsck.k9.mail.Message;
diff --git a/app/core/src/test/java/com/fsck/k9/mailstore/AttachmentResolverTest.java b/app/core/src/test/java/com/fsck/k9/mailstore/AttachmentResolverTest.java
index 3f5aa79f52ceccd267e6fb5e94c80216414a6303..6f17b323547da15a8b04c1f48a94948bf47a0030 100644
--- a/app/core/src/test/java/com/fsck/k9/mailstore/AttachmentResolverTest.java
+++ b/app/core/src/test/java/com/fsck/k9/mailstore/AttachmentResolverTest.java
@@ -5,7 +5,7 @@ import java.util.Map;
 
 import android.net.Uri;
 
-import com.fsck.k9.RobolectricTest;
+import app.k9mail.core.android.testing.RobolectricTest;
 import com.fsck.k9.mail.BodyPart;
 import com.fsck.k9.mail.Multipart;
 import com.fsck.k9.mail.Part;
diff --git a/app/core/src/test/java/com/fsck/k9/mailstore/K9BackendFolderTest.kt b/app/core/src/test/java/com/fsck/k9/mailstore/K9BackendFolderTest.kt
index 081a53ac300ab0206ea00447d85850873cc6daa5..b4d03d9529ab3eea24732cbb9c19fd68af93a45f 100644
--- a/app/core/src/test/java/com/fsck/k9/mailstore/K9BackendFolderTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/mailstore/K9BackendFolderTest.kt
@@ -2,6 +2,13 @@ package com.fsck.k9.mailstore
 
 import android.database.sqlite.SQLiteDatabase
 import androidx.core.content.contentValuesOf
+import assertk.assertFailure
+import assertk.assertThat
+import assertk.assertions.contains
+import assertk.assertions.hasMessage
+import assertk.assertions.isEqualTo
+import assertk.assertions.isInstanceOf
+import assertk.assertions.isTrue
 import com.fsck.k9.Account
 import com.fsck.k9.K9RobolectricTest
 import com.fsck.k9.Preferences
@@ -17,9 +24,6 @@ import com.fsck.k9.mail.internet.MimeMessage
 import com.fsck.k9.mail.internet.MimeMessageHelper
 import com.fsck.k9.mail.internet.TextBody
 import org.junit.After
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertTrue
-import org.junit.Assert.fail
 import org.junit.Test
 import org.koin.core.component.inject
 
@@ -45,7 +49,7 @@ class K9BackendFolderTest : K9RobolectricTest() {
 
         val messageFlags = backendFolder.getMessageFlags(MESSAGE_SERVER_ID)
 
-        assertEquals(flags, messageFlags)
+        assertThat(messageFlags).isEqualTo(flags)
     }
 
     @Test
@@ -55,7 +59,7 @@ class K9BackendFolderTest : K9RobolectricTest() {
 
         val messageFlags = backendFolder.getMessageFlags(MESSAGE_SERVER_ID)
 
-        assertTrue(messageFlags.isEmpty())
+        assertThat(messageFlags.isEmpty()).isTrue()
     }
 
     @Test
@@ -66,29 +70,27 @@ class K9BackendFolderTest : K9RobolectricTest() {
 
         val messageFlags = backendFolder.getMessageFlags(MESSAGE_SERVER_ID)
 
-        assertEquals(flags, messageFlags)
+        assertThat(messageFlags).isEqualTo(flags)
     }
 
     @Test
     fun saveCompleteMessage_withoutServerId_shouldThrow() {
         val message = createMessage(messageServerId = null)
 
-        try {
+        assertFailure {
             backendFolder.saveMessage(message, MessageDownloadState.FULL)
-            fail("Expected exception")
-        } catch (e: IllegalStateException) {
-        }
+        }.isInstanceOf<IllegalStateException>()
+            .hasMessage("Message requires a server ID to be set")
     }
 
     @Test
     fun savePartialMessage_withoutServerId_shouldThrow() {
         val message = createMessage(messageServerId = null)
 
-        try {
+        assertFailure {
             backendFolder.saveMessage(message, MessageDownloadState.PARTIAL)
-            fail("Expected exception")
-        } catch (e: IllegalStateException) {
-        }
+        }.isInstanceOf<IllegalStateException>()
+            .hasMessage("Message requires a server ID to be set")
     }
 
     fun createAccount(): Account {
@@ -111,7 +113,7 @@ class K9BackendFolderTest : K9RobolectricTest() {
         }
 
         val folderServerIds = backendStorage.getFolderServerIds()
-        assertTrue(FOLDER_SERVER_ID in folderServerIds)
+        assertThat(folderServerIds).contains(FOLDER_SERVER_ID)
 
         return K9BackendFolder(messageStore, saveMessageDataCreator, FOLDER_SERVER_ID)
     }
@@ -121,7 +123,7 @@ class K9BackendFolderTest : K9RobolectricTest() {
         backendFolder.saveMessage(message, MessageDownloadState.FULL)
 
         val messageServerIds = backendFolder.getMessageServerIds()
-        assertTrue(messageServerId in messageServerIds)
+        assertThat(messageServerIds).contains(messageServerId)
     }
 
     private fun createMessage(messageServerId: String?, flags: Set<Flag> = emptySet()): Message {
@@ -144,7 +146,7 @@ class K9BackendFolderTest : K9RobolectricTest() {
                 "uid = ?",
                 arrayOf(MESSAGE_SERVER_ID),
             )
-            assertEquals(1, numberOfUpdatedRows)
+            assertThat(numberOfUpdatedRows).isEqualTo(1)
         }
     }
 
diff --git a/app/core/src/test/java/com/fsck/k9/mailstore/K9BackendStorageTest.kt b/app/core/src/test/java/com/fsck/k9/mailstore/K9BackendStorageTest.kt
index ed0009a78eb3494b29e3ad520a9a326c8cf6ca1c..f2f0202f481c420093b99c52fbf7cd7d1852bdee 100644
--- a/app/core/src/test/java/com/fsck/k9/mailstore/K9BackendStorageTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/mailstore/K9BackendStorageTest.kt
@@ -1,12 +1,13 @@
 package com.fsck.k9.mailstore
 
+import assertk.assertThat
+import assertk.assertions.isEqualTo
 import com.fsck.k9.Account
 import com.fsck.k9.K9RobolectricTest
 import com.fsck.k9.Preferences
 import com.fsck.k9.backend.api.BackendStorage
 import com.fsck.k9.mail.FolderClass
 import org.junit.After
-import org.junit.Assert.assertEquals
 import org.junit.Test
 import org.koin.core.component.inject
 import org.mockito.kotlin.any
@@ -15,12 +16,10 @@ import org.mockito.kotlin.mock
 
 class K9BackendStorageTest : K9RobolectricTest() {
     val preferences: Preferences by inject()
-    val localStoreProvider: LocalStoreProvider by inject()
     val messageStoreManager: MessageStoreManager by inject()
     val saveMessageDataCreator: SaveMessageDataCreator by inject()
 
     val account: Account = createAccount()
-    val database: LockableDatabase = localStoreProvider.getInstance(account).database
     val backendStorage = createBackendStorage()
 
     @After
@@ -33,7 +32,7 @@ class K9BackendStorageTest : K9RobolectricTest() {
         backendStorage.setExtraString("testString", "someValue")
         val value = backendStorage.getExtraString("testString")
 
-        assertEquals("someValue", value)
+        assertThat(value).isEqualTo("someValue")
     }
 
     @Test
@@ -42,7 +41,7 @@ class K9BackendStorageTest : K9RobolectricTest() {
         backendStorage.setExtraString("testString", "newValue")
 
         val value = backendStorage.getExtraString("testString")
-        assertEquals("newValue", value)
+        assertThat(value).isEqualTo("newValue")
     }
 
     @Test
@@ -50,7 +49,7 @@ class K9BackendStorageTest : K9RobolectricTest() {
         backendStorage.setExtraNumber("testNumber", 42)
         val value = backendStorage.getExtraNumber("testNumber")
 
-        assertEquals(42L, value)
+        assertThat(value).isEqualTo(42L)
     }
 
     @Test
@@ -59,7 +58,7 @@ class K9BackendStorageTest : K9RobolectricTest() {
         backendStorage.setExtraNumber("testNumber", 23)
 
         val value = backendStorage.getExtraNumber("testNumber")
-        assertEquals(23L, value)
+        assertThat(value).isEqualTo(23L)
     }
 
     fun createAccount(): Account {
diff --git a/app/core/src/test/java/com/fsck/k9/mailstore/MimePartStreamParserTest.kt b/app/core/src/test/java/com/fsck/k9/mailstore/MimePartStreamParserTest.kt
index 2371b5a1aeae7ad7e5ba5a183dec563b8f19b82e..bfaae6b7e1ff7165c5ce09ce0d2c08e36668842b 100644
--- a/app/core/src/test/java/com/fsck/k9/mailstore/MimePartStreamParserTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/mailstore/MimePartStreamParserTest.kt
@@ -1,12 +1,18 @@
 package com.fsck.k9.mailstore
 
+import assertk.all
+import assertk.assertThat
+import assertk.assertions.hasSize
+import assertk.assertions.isEqualTo
+import assertk.assertions.isInstanceOf
+import com.fsck.k9.mail.assertk.body
+import com.fsck.k9.mail.assertk.bodyPart
+import com.fsck.k9.mail.assertk.bodyParts
+import com.fsck.k9.mail.assertk.mimeType
 import com.fsck.k9.mail.crlf
-import com.fsck.k9.mail.internet.MimeBodyPart
 import com.fsck.k9.mail.internet.MimeMessage
 import com.fsck.k9.mail.internet.MimeMultipart
 import java.io.ByteArrayInputStream
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertTrue
 import org.junit.Test
 
 class MimePartStreamParserTest {
@@ -35,14 +41,15 @@ class MimePartStreamParserTest {
             --1--
             """.trimIndent().crlf()
 
-        val msg = MimePartStreamParser.parse(null, ByteArrayInputStream(messageContent.toByteArray()))
+        val bodyPart = MimePartStreamParser.parse(null, ByteArrayInputStream(messageContent.toByteArray()))
 
-        val body = msg.body as MimeMultipart
-        assertEquals(2, body.count.toLong())
-
-        val messagePart = body.getBodyPart(1) as MimeBodyPart
-        assertEquals("message/rfc822", messagePart.mimeType)
-        assertTrue(messagePart.body is MimeMessage)
+        assertThat(bodyPart.body).isInstanceOf<MimeMultipart>().all {
+            bodyParts().hasSize(2)
+            bodyPart(1).all {
+                mimeType().isEqualTo("message/rfc822")
+                body().isInstanceOf<MimeMessage>()
+            }
+        }
     }
 
     @Test
@@ -71,13 +78,14 @@ class MimePartStreamParserTest {
             --1--
             """.trimIndent().crlf()
 
-        val msg = MimePartStreamParser.parse(null, ByteArrayInputStream(messageContent.toByteArray()))
-
-        val body = msg.body as MimeMultipart
-        assertEquals(2, body.count)
+        val bodyPart = MimePartStreamParser.parse(null, ByteArrayInputStream(messageContent.toByteArray()))
 
-        val messagePart = body.getBodyPart(1) as MimeBodyPart
-        assertEquals("message/rfc822", messagePart.mimeType)
-        assertTrue(messagePart.body is DeferredFileBody)
+        assertThat(bodyPart.body).isInstanceOf<MimeMultipart>().all {
+            bodyParts().hasSize(2)
+            bodyPart(1).all {
+                mimeType().isEqualTo("message/rfc822")
+                body().isInstanceOf<DeferredFileBody>()
+            }
+        }
     }
 }
diff --git a/app/core/src/test/java/com/fsck/k9/message/IdentityHeaderBuilderTest.kt b/app/core/src/test/java/com/fsck/k9/message/IdentityHeaderBuilderTest.kt
index 1b4ce118ad40007b658f9b1602a08faf598ac149..80aeb2c2a3affc1abae16bf4b73d246718c18a9e 100644
--- a/app/core/src/test/java/com/fsck/k9/message/IdentityHeaderBuilderTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/message/IdentityHeaderBuilderTest.kt
@@ -1,10 +1,13 @@
 package com.fsck.k9.message
 
+import android.net.Uri
+import app.k9mail.core.android.testing.RobolectricTest
+import assertk.Assert
 import assertk.assertThat
+import assertk.assertions.contains
 import assertk.assertions.isGreaterThan
 import com.fsck.k9.Account.QuoteStyle
 import com.fsck.k9.Identity
-import com.fsck.k9.RobolectricTest
 import com.fsck.k9.mail.internet.MimeHeaderChecker
 import com.fsck.k9.mail.internet.TextBody
 import org.junit.Test
@@ -35,6 +38,21 @@ class IdentityHeaderBuilderTest : RobolectricTest() {
         assertIsValidHeader(identityHeader)
     }
 
+    @Test
+    fun `identity header without identity name`() {
+        val identityHeader = IdentityHeaderBuilder()
+            .setIdentity(createIdentity(email = "test@domain.example", name = null))
+            .setIdentityChanged(true)
+            .setBody(TextBody("irrelevant"))
+            .setQuoteStyle(QuoteStyle.PREFIX)
+            .setMessageFormat(SimpleMessageFormat.TEXT)
+            .setQuoteTextMode(QuotedTextMode.NONE)
+            .build()
+
+        assertThat(identityHeader).containsParameter(IdentityField.EMAIL, "test@domain.example")
+        assertThat(identityHeader).containsParameter(IdentityField.NAME, "")
+    }
+
     private fun assertIsValidHeader(identityHeader: String) {
         try {
             MimeHeaderChecker.checkHeader(IDENTITY_HEADER, identityHeader)
@@ -55,3 +73,11 @@ class IdentityHeaderBuilderTest : RobolectricTest() {
         return Identity(description, name, email, signature, signatureUse, replyTo)
     }
 }
+
+private fun Assert<String>.containsParameter(identityField: IdentityField, value: String) = given { actual ->
+    assertThat("&${unfold(actual)}&").contains("&${identityField.value()}=${Uri.encode(value)}&")
+}
+
+private fun unfold(headerValue: String): String {
+    return headerValue.replace(Regex("\r?\n "), "")
+}
diff --git a/app/core/src/test/java/com/fsck/k9/message/IdentityHeaderParserTest.kt b/app/core/src/test/java/com/fsck/k9/message/IdentityHeaderParserTest.kt
index f9dd3b8c5eb1e0d975fdb631eefd59002ffdf0d3..df7aa8d0159f4fef4cde3b2d6d7d7541822aca97 100644
--- a/app/core/src/test/java/com/fsck/k9/message/IdentityHeaderParserTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/message/IdentityHeaderParserTest.kt
@@ -1,8 +1,8 @@
 package com.fsck.k9.message
 
+import app.k9mail.core.android.testing.RobolectricTest
 import assertk.assertThat
 import assertk.assertions.contains
-import com.fsck.k9.RobolectricTest
 import com.fsck.k9.helper.toCrLf
 import org.junit.Test
 
diff --git a/app/core/src/test/java/com/fsck/k9/message/MessageBuilderTest.java b/app/core/src/test/java/com/fsck/k9/message/MessageBuilderTest.java
index 267e448b838175f89a82242ecbc3b221fb5b901d..0aec39fe846ad983f6a56a9947b3ebbb9d161090 100644
--- a/app/core/src/test/java/com/fsck/k9/message/MessageBuilderTest.java
+++ b/app/core/src/test/java/com/fsck/k9/message/MessageBuilderTest.java
@@ -1,6 +1,5 @@
 package com.fsck.k9.message;
 
-
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.FileOutputStream;
@@ -13,10 +12,10 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
+import app.k9mail.core.android.testing.RobolectricTest;
 import com.fsck.k9.Account.QuoteStyle;
 import com.fsck.k9.CoreResourceProvider;
 import com.fsck.k9.Identity;
-import com.fsck.k9.RobolectricTest;
 import com.fsck.k9.TestCoreResourceProvider;
 import com.fsck.k9.mail.Address;
 import com.fsck.k9.mail.BodyPart;
diff --git a/app/core/src/test/java/com/fsck/k9/message/ReplyActionStrategyTest.kt b/app/core/src/test/java/com/fsck/k9/message/ReplyActionStrategyTest.kt
index 868ab0718c4990e0e69a193c1e879077d1abe151..44aeea32c25221be1334a4281c587964936254e3 100644
--- a/app/core/src/test/java/com/fsck/k9/message/ReplyActionStrategyTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/message/ReplyActionStrategyTest.kt
@@ -39,8 +39,8 @@ class ReplyActionStrategyTest {
 
         val replyActions = replyActionStrategy.getReplyActions(account, message)
 
-        assertThat(replyActions.defaultAction).isEqualTo(ReplyAction.REPLY_ALL)
-        assertThat(replyActions.additionalActions).containsExactly(ReplyAction.REPLY)
+        assertThat(replyActions.defaultAction).isEqualTo(ReplyAction.REPLY)
+        assertThat(replyActions.additionalActions).containsExactly(ReplyAction.REPLY_ALL)
     }
 
     @Test
@@ -52,8 +52,8 @@ class ReplyActionStrategyTest {
 
         val replyActions = replyActionStrategy.getReplyActions(account, message)
 
-        assertThat(replyActions.defaultAction).isEqualTo(ReplyAction.REPLY_ALL)
-        assertThat(replyActions.additionalActions).containsExactly(ReplyAction.REPLY)
+        assertThat(replyActions.defaultAction).isEqualTo(ReplyAction.REPLY)
+        assertThat(replyActions.additionalActions).containsExactly(ReplyAction.REPLY_ALL)
     }
 
     @Test
@@ -66,8 +66,8 @@ class ReplyActionStrategyTest {
 
         val replyActions = replyActionStrategy.getReplyActions(account, message)
 
-        assertThat(replyActions.defaultAction).isEqualTo(ReplyAction.REPLY_ALL)
-        assertThat(replyActions.additionalActions).containsExactly(ReplyAction.REPLY)
+        assertThat(replyActions.defaultAction).isEqualTo(ReplyAction.REPLY)
+        assertThat(replyActions.additionalActions).containsExactly(ReplyAction.REPLY_ALL)
     }
 
     @Test
@@ -80,8 +80,8 @@ class ReplyActionStrategyTest {
 
         val replyActions = replyActionStrategy.getReplyActions(account, message)
 
-        assertThat(replyActions.defaultAction).isEqualTo(ReplyAction.REPLY_ALL)
-        assertThat(replyActions.additionalActions).containsExactly(ReplyAction.REPLY)
+        assertThat(replyActions.defaultAction).isEqualTo(ReplyAction.REPLY)
+        assertThat(replyActions.additionalActions).containsExactly(ReplyAction.REPLY_ALL)
     }
 
     @Test
@@ -93,8 +93,8 @@ class ReplyActionStrategyTest {
 
         val replyActions = replyActionStrategy.getReplyActions(account, message)
 
-        assertThat(replyActions.defaultAction).isEqualTo(ReplyAction.REPLY_ALL)
-        assertThat(replyActions.additionalActions).containsExactly(ReplyAction.REPLY)
+        assertThat(replyActions.defaultAction).isEqualTo(ReplyAction.REPLY)
+        assertThat(replyActions.additionalActions).containsExactly(ReplyAction.REPLY_ALL)
     }
 
     @Test
diff --git a/app/core/src/test/java/com/fsck/k9/message/extractors/AttachmentInfoExtractorTest.java b/app/core/src/test/java/com/fsck/k9/message/extractors/AttachmentInfoExtractorTest.java
index c83476a9b24bb7eaf6fa5c77155ad3eed7723808..e076676ca0c78cb1b51c66dd3c034d2e4962357e 100644
--- a/app/core/src/test/java/com/fsck/k9/message/extractors/AttachmentInfoExtractorTest.java
+++ b/app/core/src/test/java/com/fsck/k9/message/extractors/AttachmentInfoExtractorTest.java
@@ -1,11 +1,10 @@
 package com.fsck.k9.message.extractors;
 
-
 import android.content.Context;
 import android.net.Uri;
 import androidx.annotation.Nullable;
 
-import com.fsck.k9.RobolectricTest;
+import app.k9mail.core.android.testing.RobolectricTest;
 import com.fsck.k9.mail.Part;
 import com.fsck.k9.mail.internet.MimeBodyPart;
 import com.fsck.k9.mail.internet.MimeHeader;
diff --git a/app/core/src/test/java/com/fsck/k9/message/html/DisplayHtmlTest.kt b/app/core/src/test/java/com/fsck/k9/message/html/DisplayHtmlTest.kt
index 5789d6acda1ef847c883fe5739f62812c66dab4d..90b697ce866acbd7dda20415c0aa59a8eb147fb1 100644
--- a/app/core/src/test/java/com/fsck/k9/message/html/DisplayHtmlTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/message/html/DisplayHtmlTest.kt
@@ -1,31 +1,34 @@
 package com.fsck.k9.message.html
 
+import assertk.Assert
+import assertk.assertThat
+import assertk.assertions.hasSize
+import assertk.assertions.isEqualTo
 import org.jsoup.Jsoup
-import org.junit.Assert.assertEquals
 import org.junit.Test
 
 class DisplayHtmlTest {
-    val displayHtml = DisplayHtml(HtmlSettings(useDarkMode = false, useFixedWidthFont = false))
+    private val displayHtml = DisplayHtml(HtmlSettings(useDarkMode = false, useFixedWidthFont = false))
 
     @Test
     fun wrapMessageContent_addsViewportMetaElement() {
         val html = displayHtml.wrapMessageContent("Some text")
 
-        assertHtmlContainsElement(html, "head > meta[name=viewport]")
+        assertThat(html).containsHtmlElement("head > meta[name=viewport]")
     }
 
     @Test
     fun wrapMessageContent_setsDirToAuto() {
         val html = displayHtml.wrapMessageContent("Some text")
 
-        assertHtmlContainsElement(html, "html[dir=auto]")
+        assertThat(html).containsHtmlElement("html[dir=auto]")
     }
 
     @Test
     fun wrapMessageContent_addsPreCSS() {
         val html = displayHtml.wrapMessageContent("Some text")
 
-        assertHtmlContainsElement(html, "head > style")
+        assertThat(html).containsHtmlElement("head > style")
     }
 
     @Test
@@ -34,16 +37,18 @@ class DisplayHtmlTest {
 
         val html = displayHtml.wrapMessageContent(content)
 
-        assertEquals(content, Jsoup.parse(html).body().text())
+        assertThat(html).bodyText().isEqualTo(content)
     }
 
-    private fun assertHtmlContainsElement(html: String, cssQuery: String, numberOfExpectedOccurrences: Int = 1) {
-        val document = Jsoup.parse(html)
-        val numberOfFoundElements = document.select(cssQuery).size
-        assertEquals(
-            "Expected to find '$cssQuery' $numberOfExpectedOccurrences time(s) in:\n$html",
-            numberOfExpectedOccurrences,
-            numberOfFoundElements,
-        )
+    private fun Assert<String>.containsHtmlElement(cssQuery: String) = given { actual ->
+        assertThat(actual).htmlElements(cssQuery).hasSize(1)
+    }
+
+    private fun Assert<String>.htmlElements(cssQuery: String) = transform { html ->
+        Jsoup.parse(html).select(cssQuery)
+    }
+
+    private fun Assert<String>.bodyText() = transform { html ->
+        Jsoup.parse(html).body().text()
     }
 }
diff --git a/app/core/src/test/java/com/fsck/k9/message/html/GenericUriParserTest.kt b/app/core/src/test/java/com/fsck/k9/message/html/GenericUriParserTest.kt
index 7ec7312d90b1236b7a7e4968d97c1afc2603b241..9787809c5fe0f1be5a7ddc8d5adabc88999da902 100644
--- a/app/core/src/test/java/com/fsck/k9/message/html/GenericUriParserTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/message/html/GenericUriParserTest.kt
@@ -1,11 +1,12 @@
 package com.fsck.k9.message.html
 
+import assertk.assertFailure
 import assertk.assertThat
 import assertk.assertions.hasMessage
 import assertk.assertions.isEqualTo
-import assertk.assertions.isFailure
 import assertk.assertions.isInstanceOf
-import kotlin.test.assertNotNull
+import assertk.assertions.isNotNull
+import assertk.assertions.prop
 import org.junit.Test
 
 class GenericUriParserTest {
@@ -67,27 +68,24 @@ class GenericUriParserTest {
 
     @Test
     fun `negative 'startPos' value`() {
-        assertThat {
+        assertFailure {
             parser.parseUri("test", -1)
-        }.isFailure()
-            .isInstanceOf(IllegalArgumentException::class)
+        }.isInstanceOf<IllegalArgumentException>()
             .hasMessage("Invalid 'startPos' value")
     }
 
     @Test
     fun `out of bounds 'startPos' value`() {
-        assertThat {
+        assertFailure {
             parser.parseUri("test", 4)
-        }.isFailure()
-            .isInstanceOf(IllegalArgumentException::class)
+        }.isInstanceOf<IllegalArgumentException>()
             .hasMessage("Invalid 'startPos' value")
     }
 
     private fun assertUriValid(input: String) {
         val result = parser.parseUri(input, 0)
 
-        assertNotNull(result) { uriMatch ->
-            assertThat(uriMatch.uri).isEqualTo(input)
-        }
+        assertThat(result).isNotNull()
+            .prop(UriMatch::uri).isEqualTo(input)
     }
 }
diff --git a/app/core/src/test/java/com/fsck/k9/message/html/HttpUriParserTest.kt b/app/core/src/test/java/com/fsck/k9/message/html/HttpUriParserTest.kt
index 235b6c24f594c730d79b3bcbc79d161b5e5320f9..3c8a61842a71796b5fc6ae9a1f25020b91cadec4 100644
--- a/app/core/src/test/java/com/fsck/k9/message/html/HttpUriParserTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/message/html/HttpUriParserTest.kt
@@ -1,9 +1,9 @@
 package com.fsck.k9.message.html
 
+import assertk.assertFailure
 import assertk.assertThat
 import assertk.assertions.hasMessage
 import assertk.assertions.isEqualTo
-import assertk.assertions.isFailure
 import assertk.assertions.isInstanceOf
 import assertk.assertions.isNotNull
 import assertk.assertions.isNull
@@ -287,19 +287,17 @@ class HttpUriParserTest {
 
     @Test
     fun `negative 'startPos' value`() {
-        assertThat {
+        assertFailure {
             parser.parseUri("test", -1)
-        }.isFailure()
-            .isInstanceOf(IllegalArgumentException::class)
+        }.isInstanceOf<IllegalArgumentException>()
             .hasMessage("Invalid 'startPos' value")
     }
 
     @Test
     fun `out of bounds 'startPos' value`() {
-        assertThat {
+        assertFailure {
             parser.parseUri("test", 4)
-        }.isFailure()
-            .isInstanceOf(IllegalArgumentException::class)
+        }.isInstanceOf<IllegalArgumentException>()
             .hasMessage("Invalid 'startPos' value")
     }
 
diff --git a/app/core/src/test/java/com/fsck/k9/message/html/UriMatcherTest.kt b/app/core/src/test/java/com/fsck/k9/message/html/UriMatcherTest.kt
index fd0b02ecd34121771a79615370474c3f32b7ad9d..16ef2dcdcfacfff70bf431c544207d6d7eb86225 100644
--- a/app/core/src/test/java/com/fsck/k9/message/html/UriMatcherTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/message/html/UriMatcherTest.kt
@@ -1,10 +1,13 @@
 package com.fsck.k9.message.html
 
+import assertk.Assert
 import assertk.assertThat
 import assertk.assertions.hasSize
 import assertk.assertions.isEmpty
 import assertk.assertions.isEqualTo
+import assertk.assertions.isFalse
 import assertk.assertions.isNotEqualTo
+import assertk.assertions.isTrue
 import org.junit.Test
 
 class UriMatcherTest {
@@ -82,6 +85,27 @@ class UriMatcherTest {
         )
     }
 
+    @Test
+    fun `valid URIs`() {
+        assertThat("http://domain.example").isValidUri()
+        assertThat("https://domain.example/").isValidUri()
+        assertThat("mailto:user@domain.example").isValidUri()
+    }
+
+    @Test
+    fun `not URIs`() {
+        assertThat("some text here").isNotValidUri()
+        assertThat("some text including the string http:").isNotValidUri()
+        assertThat("some text including an email address without URI scheme: user@domain.example").isNotValidUri()
+    }
+
+    @Test
+    fun `valid URIs surrounded by other characters`() {
+        assertThat("text https://domain.example/").isNotValidUri()
+        assertThat("https://domain.example/ text").isNotValidUri()
+        assertThat("<https://domain.example/>").isNotValidUri()
+    }
+
     private fun assertNoMatch(text: String) {
         val uriMatches = UriMatcher.findUris(text)
         assertThat(uriMatches).isEmpty()
@@ -104,3 +128,11 @@ class UriMatcherTest {
         }
     }
 }
+
+private fun Assert<String>.isValidUri() = given { actual ->
+    assertThat(UriMatcher.isValidUri(actual)).isTrue()
+}
+
+private fun Assert<String>.isNotValidUri() = given { actual ->
+    assertThat(UriMatcher.isValidUri(actual)).isFalse()
+}
diff --git a/app/core/src/test/java/com/fsck/k9/message/quote/TextQuoteCreatorTest.kt b/app/core/src/test/java/com/fsck/k9/message/quote/TextQuoteCreatorTest.kt
index aa5f4287c17de75c20e0943672c32deb8d55294d..b36b0972d4433791fdbdd19e3ce3886183b499cc 100644
--- a/app/core/src/test/java/com/fsck/k9/message/quote/TextQuoteCreatorTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/message/quote/TextQuoteCreatorTest.kt
@@ -1,9 +1,9 @@
 package com.fsck.k9.message.quote
 
+import app.k9mail.core.android.testing.RobolectricTest
 import assertk.assertThat
 import assertk.assertions.isEqualTo
 import com.fsck.k9.Account.QuoteStyle
-import com.fsck.k9.RobolectricTest
 import com.fsck.k9.TestCoreResourceProvider
 import com.fsck.k9.mail.Address
 import com.fsck.k9.mail.Message
diff --git a/app/core/src/test/java/com/fsck/k9/notification/AuthenticationErrorNotificationControllerTest.kt b/app/core/src/test/java/com/fsck/k9/notification/AuthenticationErrorNotificationControllerTest.kt
index c0665d0bd0afd145a55befe8b81ed4666edd7b70..7b0be0b876e8a7df04f7b6f16a5fa98e2e8c11a4 100644
--- a/app/core/src/test/java/com/fsck/k9/notification/AuthenticationErrorNotificationControllerTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/notification/AuthenticationErrorNotificationControllerTest.kt
@@ -5,8 +5,8 @@ import android.app.PendingIntent
 import androidx.core.app.NotificationCompat
 import androidx.core.app.NotificationManagerCompat
 import androidx.test.core.app.ApplicationProvider
+import app.k9mail.core.android.testing.RobolectricTest
 import com.fsck.k9.Account
-import com.fsck.k9.RobolectricTest
 import com.fsck.k9.testing.MockHelper.mockBuilder
 import org.junit.Test
 import org.mockito.Mockito.verify
diff --git a/app/core/src/test/java/com/fsck/k9/notification/BaseNotificationDataCreatorTest.kt b/app/core/src/test/java/com/fsck/k9/notification/BaseNotificationDataCreatorTest.kt
index 43e56a824daf928d2b42012e2345d31fa1f17614..1483f69864000e03d4537b640987d64c60fc57ac 100644
--- a/app/core/src/test/java/com/fsck/k9/notification/BaseNotificationDataCreatorTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/notification/BaseNotificationDataCreatorTest.kt
@@ -127,7 +127,7 @@ class BaseNotificationDataCreatorTest {
 
         val result = notificationDataCreator.createBaseNotificationData(notificationData)
 
-        assertThat(result.lockScreenNotificationData).isInstanceOf(LockScreenNotificationData.SenderNames::class.java)
+        assertThat(result.lockScreenNotificationData).isInstanceOf<LockScreenNotificationData.SenderNames>()
         val senderNamesData = result.lockScreenNotificationData as LockScreenNotificationData.SenderNames
         assertThat(senderNamesData.senderNames).isEqualTo("Sender One, Sender Two, Sender Three")
     }
diff --git a/app/core/src/test/java/com/fsck/k9/notification/CertificateErrorNotificationControllerTest.kt b/app/core/src/test/java/com/fsck/k9/notification/CertificateErrorNotificationControllerTest.kt
index 7d74127f6344609d8f1895afb8808abb59321150..674e8aed5ec61fc18b763fde0c4c98aa545944e8 100644
--- a/app/core/src/test/java/com/fsck/k9/notification/CertificateErrorNotificationControllerTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/notification/CertificateErrorNotificationControllerTest.kt
@@ -5,8 +5,8 @@ import android.app.PendingIntent
 import androidx.core.app.NotificationCompat
 import androidx.core.app.NotificationManagerCompat
 import androidx.test.core.app.ApplicationProvider
+import app.k9mail.core.android.testing.RobolectricTest
 import com.fsck.k9.Account
-import com.fsck.k9.RobolectricTest
 import com.fsck.k9.testing.MockHelper.mockBuilder
 import org.junit.Test
 import org.mockito.Mockito.verify
diff --git a/app/core/src/test/java/com/fsck/k9/notification/LockScreenNotificationCreatorTest.kt b/app/core/src/test/java/com/fsck/k9/notification/LockScreenNotificationCreatorTest.kt
index 1d999dfe97436a3fc4e302059a65d8e9089ffd9a..83ae93ccbad131bc1821edcd67e00ccc261ec39b 100644
--- a/app/core/src/test/java/com/fsck/k9/notification/LockScreenNotificationCreatorTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/notification/LockScreenNotificationCreatorTest.kt
@@ -2,8 +2,8 @@ package com.fsck.k9.notification
 
 import androidx.core.app.NotificationCompat
 import androidx.test.core.app.ApplicationProvider
+import app.k9mail.core.android.testing.RobolectricTest
 import com.fsck.k9.Account
-import com.fsck.k9.RobolectricTest
 import com.fsck.k9.testing.MockHelper.mockBuilder
 import org.junit.Test
 import org.mockito.Mockito.verify
diff --git a/app/core/src/test/java/com/fsck/k9/notification/NewMailNotificationManagerTest.kt b/app/core/src/test/java/com/fsck/k9/notification/NewMailNotificationManagerTest.kt
index aec8dcfbb15c08485dd74165505f48da6a5e959c..b7c4ee1151e3573da7d4bee79e28103d0b8ed579 100644
--- a/app/core/src/test/java/com/fsck/k9/notification/NewMailNotificationManagerTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/notification/NewMailNotificationManagerTest.kt
@@ -70,7 +70,7 @@ class NewMailNotificationManagerTest {
                 summary = "summary",
             ),
         )
-        assertThat(result.summaryNotificationData).isNotNull().isInstanceOf(SummarySingleNotificationData::class.java)
+        assertThat(result.summaryNotificationData).isNotNull().isInstanceOf<SummarySingleNotificationData>()
         val summaryNotificationData = result.summaryNotificationData as SummarySingleNotificationData
         assertThat(summaryNotificationData.singleNotificationData.isSilent).isFalse()
     }
@@ -108,7 +108,7 @@ class NewMailNotificationManagerTest {
             ),
         )
         assertThat(result.baseNotificationData.newMessagesCount).isEqualTo(2)
-        assertThat(result.summaryNotificationData).isNotNull().isInstanceOf(SummaryInboxNotificationData::class.java)
+        assertThat(result.summaryNotificationData).isNotNull().isInstanceOf<SummaryInboxNotificationData>()
         val summaryNotificationData = result.summaryNotificationData as SummaryInboxNotificationData
         assertThat(summaryNotificationData.content).isEqualTo(listOf("Zoe Meeting", "Alice Hi Bob"))
         assertThat(summaryNotificationData.messageReferences).isEqualTo(
@@ -229,7 +229,7 @@ class NewMailNotificationManagerTest {
             assertThat(data.cancelNotificationIds).isEqualTo(listOf(notificationIdTwo))
             assertThat(data.singleNotificationData).isEmpty()
             assertThat(data.baseNotificationData.newMessagesCount).isEqualTo(2)
-            assertThat(data.summaryNotificationData).isNotNull().isInstanceOf(SummaryInboxNotificationData::class.java)
+            assertThat(data.summaryNotificationData).isNotNull().isInstanceOf<SummaryInboxNotificationData>()
             val summaryNotificationData = data.summaryNotificationData as SummaryInboxNotificationData
             assertThat(summaryNotificationData.content).isEqualTo(listOf("Alice Three", "Alice One"))
             assertThat(summaryNotificationData.messageReferences).isEqualTo(
@@ -317,7 +317,7 @@ class NewMailNotificationManagerTest {
                 ),
             )
 
-            assertThat(data.summaryNotificationData).isNotNull().isInstanceOf(SummarySingleNotificationData::class.java)
+            assertThat(data.summaryNotificationData).isNotNull().isInstanceOf<SummarySingleNotificationData>()
             val summaryNotificationData = data.summaryNotificationData as SummarySingleNotificationData
             assertThat(summaryNotificationData.singleNotificationData.isSilent).isTrue()
             assertThat(summaryNotificationData.singleNotificationData.content).isEqualTo(
@@ -354,7 +354,7 @@ class NewMailNotificationManagerTest {
             assertThat(data.singleNotificationData).hasSize(MAX_NUMBER_OF_NEW_MESSAGE_NOTIFICATIONS)
             assertThat(data.singleNotificationData.map { it.content.sender }).doesNotContain("inactive")
 
-            assertThat(data.summaryNotificationData).isNotNull().isInstanceOf(SummaryInboxNotificationData::class.java)
+            assertThat(data.summaryNotificationData).isNotNull().isInstanceOf<SummaryInboxNotificationData>()
             val summaryNotificationData = data.summaryNotificationData as SummaryInboxNotificationData
             assertThat(summaryNotificationData.isSilent).isTrue()
         }
diff --git a/app/core/src/test/java/com/fsck/k9/notification/NotificationContentCreatorTest.kt b/app/core/src/test/java/com/fsck/k9/notification/NotificationContentCreatorTest.kt
index e5670c880e7e5dd68b847200809163aed35b3d86..190b4b2bcb7951eabc438742217d929bb4f33b47 100644
--- a/app/core/src/test/java/com/fsck/k9/notification/NotificationContentCreatorTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/notification/NotificationContentCreatorTest.kt
@@ -1,10 +1,10 @@
 package com.fsck.k9.notification
 
 import app.k9mail.core.android.common.contact.ContactRepository
+import app.k9mail.core.android.testing.RobolectricTest
 import assertk.assertThat
 import assertk.assertions.isEqualTo
 import com.fsck.k9.Account
-import com.fsck.k9.RobolectricTest
 import com.fsck.k9.controller.MessageReference
 import com.fsck.k9.mail.Address
 import com.fsck.k9.mail.Message.RecipientType
diff --git a/app/core/src/test/java/com/fsck/k9/notification/NotificationDataStoreTest.kt b/app/core/src/test/java/com/fsck/k9/notification/NotificationDataStoreTest.kt
index 781acaf6554248e4a1791f70b603be8ad02a49d5..192c1458124daf8814dcf5a64268d35dc131f207 100644
--- a/app/core/src/test/java/com/fsck/k9/notification/NotificationDataStoreTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/notification/NotificationDataStoreTest.kt
@@ -1,5 +1,6 @@
 package com.fsck.k9.notification
 
+import app.k9mail.core.android.testing.RobolectricTest
 import assertk.assertThat
 import assertk.assertions.containsExactly
 import assertk.assertions.hasSize
@@ -12,7 +13,6 @@ import assertk.assertions.isNull
 import assertk.assertions.isSameAs
 import assertk.assertions.isTrue
 import com.fsck.k9.Account
-import com.fsck.k9.RobolectricTest
 import com.fsck.k9.controller.MessageReference
 import kotlin.test.assertNotNull
 import org.junit.Test
@@ -131,7 +131,7 @@ class NotificationDataStoreTest : RobolectricTest() {
             assertThat(removeResult.notificationHolders).hasSize(0)
             assertThat(removeResult.notificationStoreOperations).hasSize(MAX_NUMBER_OF_NEW_MESSAGE_NOTIFICATIONS + 1)
             for (notificationStoreOperation in removeResult.notificationStoreOperations) {
-                assertThat(notificationStoreOperation).isInstanceOf(NotificationStoreOperation.Remove::class.java)
+                assertThat(notificationStoreOperation).isInstanceOf<NotificationStoreOperation.Remove>()
             }
         }
     }
diff --git a/app/core/src/test/java/com/fsck/k9/notification/NotificationIdsTest.kt b/app/core/src/test/java/com/fsck/k9/notification/NotificationIdsTest.kt
index 24fec67997b721a0d7e5c564f92ba896d01ee21e..62cb930870fb0bf909f9a40b3c0944badf530c5b 100644
--- a/app/core/src/test/java/com/fsck/k9/notification/NotificationIdsTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/notification/NotificationIdsTest.kt
@@ -96,7 +96,7 @@ class NotificationIdsTest {
     }
 
     private fun getGeneralNotificationIds(): List<Int> {
-        return listOf(NotificationIds.PUSH_NOTIFICATION_ID)
+        return listOf(NotificationIds.PUSH_NOTIFICATION_ID, NotificationIds.BACKGROUND_WORK_NOTIFICATION_ID)
     }
 
     private fun getAccountNotificationIds(account: Account): List<Int> {
diff --git a/app/core/src/test/java/com/fsck/k9/notification/SendFailedNotificationControllerTest.kt b/app/core/src/test/java/com/fsck/k9/notification/SendFailedNotificationControllerTest.kt
index 7c41e81fb18145ad73be43a2c9b7504c8fbbfa4d..202efa3a4dc637e7d4389714e270fcfffc76dc8e 100644
--- a/app/core/src/test/java/com/fsck/k9/notification/SendFailedNotificationControllerTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/notification/SendFailedNotificationControllerTest.kt
@@ -5,8 +5,8 @@ import android.app.PendingIntent
 import androidx.core.app.NotificationCompat
 import androidx.core.app.NotificationManagerCompat
 import androidx.test.core.app.ApplicationProvider
+import app.k9mail.core.android.testing.RobolectricTest
 import com.fsck.k9.Account
-import com.fsck.k9.RobolectricTest
 import com.fsck.k9.testing.MockHelper.mockBuilder
 import org.junit.Test
 import org.mockito.ArgumentMatchers.anyLong
diff --git a/app/core/src/test/java/com/fsck/k9/notification/SummaryNotificationDataCreatorTest.kt b/app/core/src/test/java/com/fsck/k9/notification/SummaryNotificationDataCreatorTest.kt
index ed50ac4f3f614ab4a7fc954f31460c0280c18f82..48db6d7d97fc2a97c7cbb7b5778a0c0d7e8726ac 100644
--- a/app/core/src/test/java/com/fsck/k9/notification/SummaryNotificationDataCreatorTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/notification/SummaryNotificationDataCreatorTest.kt
@@ -51,7 +51,7 @@ class SummaryNotificationDataCreatorTest {
             silent = false,
         )
 
-        assertThat(result).isInstanceOf(SummarySingleNotificationData::class.java)
+        assertThat(result).isInstanceOf<SummarySingleNotificationData>()
     }
 
     @Test
diff --git a/app/core/src/test/java/com/fsck/k9/notification/SyncNotificationControllerTest.kt b/app/core/src/test/java/com/fsck/k9/notification/SyncNotificationControllerTest.kt
index 156207dae92060fbee2a5e51da309a238a47fdb4..edbdd87c6b74dc1727f16eb7af3df8c8307fd259 100644
--- a/app/core/src/test/java/com/fsck/k9/notification/SyncNotificationControllerTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/notification/SyncNotificationControllerTest.kt
@@ -5,8 +5,8 @@ import android.app.PendingIntent
 import androidx.core.app.NotificationCompat
 import androidx.core.app.NotificationManagerCompat
 import androidx.test.core.app.ApplicationProvider
+import app.k9mail.core.android.testing.RobolectricTest
 import com.fsck.k9.Account
-import com.fsck.k9.RobolectricTest
 import com.fsck.k9.mailstore.LocalFolder
 import com.fsck.k9.notification.NotificationIds.getFetchingMailNotificationId
 import com.fsck.k9.testing.MockHelper.mockBuilder
diff --git a/app/core/src/test/java/com/fsck/k9/notification/TestNotificationResourceProvider.kt b/app/core/src/test/java/com/fsck/k9/notification/TestNotificationResourceProvider.kt
index b347bc7a4676bfeac40a63d1d17c3fb085659f61..e37e6161dd260751588c30d8c0171fb6e72aeec2 100644
--- a/app/core/src/test/java/com/fsck/k9/notification/TestNotificationResourceProvider.kt
+++ b/app/core/src/test/java/com/fsck/k9/notification/TestNotificationResourceProvider.kt
@@ -13,6 +13,7 @@ class TestNotificationResourceProvider : NotificationResourceProvider {
     override val wearIconArchive: Int = 10
     override val wearIconReplyAll: Int = 11
     override val wearIconMarkAsSpam: Int = 12
+    override val iconBackgroundWorkNotification: Int = 13
 
     override val pushChannelName = "Synchronize (Push)"
     override val pushChannelDescription = "Displayed while waiting for new messages"
diff --git a/app/core/src/test/java/com/fsck/k9/preferences/SettingsExporterTest.kt b/app/core/src/test/java/com/fsck/k9/preferences/SettingsExporterTest.kt
index 79f24f2d09b52dec5056faf4241743a5396e088a..b098ab1b3e3e51f6fbce9051f037a488f9f7e445 100644
--- a/app/core/src/test/java/com/fsck/k9/preferences/SettingsExporterTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/preferences/SettingsExporterTest.kt
@@ -1,14 +1,15 @@
 package com.fsck.k9.preferences
 
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.isNotNull
+import assertk.assertions.isNull
 import com.fsck.k9.K9RobolectricTest
 import com.fsck.k9.Preferences
 import com.fsck.k9.mailstore.FolderRepository
 import java.io.ByteArrayOutputStream
 import org.jdom2.Document
 import org.jdom2.input.SAXBuilder
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNotNull
-import org.junit.Assert.assertNull
 import org.junit.Test
 import org.koin.core.component.inject
 import org.mockito.kotlin.mock
@@ -31,35 +32,35 @@ class SettingsExporterTest : K9RobolectricTest() {
     fun exportPreferences_producesXML() {
         val document = exportPreferences(false, emptySet())
 
-        assertEquals("k9settings", document.rootElement.name)
+        assertThat(document.rootElement.name).isEqualTo("k9settings")
     }
 
     @Test
     fun exportPreferences_setsVersionToLatest() {
         val document = exportPreferences(false, emptySet())
 
-        assertEquals(Settings.VERSION.toString(), document.rootElement.getAttributeValue("version"))
+        assertThat(document.rootElement.getAttributeValue("version")).isEqualTo(Settings.VERSION.toString())
     }
 
     @Test
     fun exportPreferences_setsFormatTo1() {
         val document = exportPreferences(false, emptySet())
 
-        assertEquals("1", document.rootElement.getAttributeValue("format"))
+        assertThat(document.rootElement.getAttributeValue("format")).isEqualTo("1")
     }
 
     @Test
     fun exportPreferences_exportsGlobalSettingsWhenRequested() {
         val document = exportPreferences(true, emptySet())
 
-        assertNotNull(document.rootElement.getChild("global"))
+        assertThat(document.rootElement.getChild("global")).isNotNull()
     }
 
     @Test
     fun exportPreferences_ignoresGlobalSettingsWhenRequested() {
         val document = exportPreferences(false, emptySet())
 
-        assertNull(document.rootElement.getChild("global"))
+        assertThat(document.rootElement.getChild("global")).isNull()
     }
 
     private fun exportPreferences(globalSettings: Boolean, accounts: Set<String>): Document {
diff --git a/app/core/src/test/java/com/fsck/k9/sasl/OAuthBearerTest.kt b/app/core/src/test/java/com/fsck/k9/sasl/OAuthBearerTest.kt
index fbb10d62622e280a58f76a953bb51868122f4479..e0b38dd83d3520466c8d7ac71cec01c403287282 100644
--- a/app/core/src/test/java/com/fsck/k9/sasl/OAuthBearerTest.kt
+++ b/app/core/src/test/java/com/fsck/k9/sasl/OAuthBearerTest.kt
@@ -29,4 +29,15 @@ class OAuthBearerTest {
         assertThat(result.decodeBase64()?.utf8())
             .isEqualTo("n,a=user=3Dname@domain.example,\u0001auth=Bearer token\u0001\u0001")
     }
+
+    @Test
+    fun `username contains comma that needs to be encoded`() {
+        val username = "user,name"
+        val token = "token"
+
+        val result = buildOAuthBearerInitialClientResponse(username, token)
+
+        assertThat(result).isEqualTo("bixhPXVzZXI9MkNuYW1lLAFhdXRoPUJlYXJlciB0b2tlbgEB")
+        assertThat(result.decodeBase64()?.utf8()).isEqualTo("n,a=user=2Cname,\u0001auth=Bearer token\u0001\u0001")
+    }
 }
diff --git a/app/core/src/test/java/com/fsck/k9/setup/ServerNameSuggesterTest.java b/app/core/src/test/java/com/fsck/k9/setup/ServerNameSuggesterTest.java
deleted file mode 100644
index c1ba6adad720f62f069eb4d0b3d8817e9a11ec1a..0000000000000000000000000000000000000000
--- a/app/core/src/test/java/com/fsck/k9/setup/ServerNameSuggesterTest.java
+++ /dev/null
@@ -1,49 +0,0 @@
-package com.fsck.k9.setup;
-
-
-import com.fsck.k9.preferences.Protocols;
-import org.junit.Before;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-
-
-public class ServerNameSuggesterTest {
-    private ServerNameSuggester serverNameSuggester;
-
-
-    @Before
-    public void setUp() throws Exception {
-        serverNameSuggester = new ServerNameSuggester();
-    }
-
-    @Test
-    public void suggestServerName_forImapServer() throws Exception {
-        String serverType = Protocols.IMAP;
-        String domainPart = "example.org";
-
-        String result = serverNameSuggester.suggestServerName(serverType, domainPart);
-
-        assertEquals("imap.example.org", result);
-    }
-
-    @Test
-    public void suggestServerName_forPop3Server() throws Exception {
-        String serverType = Protocols.POP3;
-        String domainPart = "example.org";
-
-        String result = serverNameSuggester.suggestServerName(serverType, domainPart);
-
-        assertEquals("pop3.example.org", result);
-    }
-
-    @Test
-    public void suggestServerName_forSmtpServer() throws Exception {
-        String serverType = Protocols.SMTP;
-        String domainPart = "example.org";
-
-        String result = serverNameSuggester.suggestServerName(serverType, domainPart);
-
-        assertEquals("smtp.example.org", result);
-    }
-}
diff --git a/app/k9mail/build.gradle.kts b/app/k9mail/build.gradle.kts
index 311a981a97b8ba0423ac69a0cda53ea1e1eb567b..582a832d53989ec0bbf09ed5f990760c422445f1 100644
--- a/app/k9mail/build.gradle.kts
+++ b/app/k9mail/build.gradle.kts
@@ -17,6 +17,12 @@ dependencies {
     implementation(projects.backend.pop3)
     debugImplementation(projects.backend.demo)
 
+    implementation(projects.core.featureflags)
+    implementation(projects.feature.launcher)
+
+    // TODO remove account setup dependency
+    implementation(projects.feature.account.setup)
+
     implementation(libs.androidx.appcompat)
     implementation(libs.androidx.core.ktx)
     implementation(libs.androidx.work.ktx)
@@ -46,8 +52,8 @@ android {
         applicationId = "foundation.e.mail"
         testApplicationId = "foundation.e.mail.tests"
 
-        versionCode = 37003
-        versionName = "6.703"
+        versionCode = 37010
+        versionName = "6.710"
 
         // Keep in sync with the resource string array "supported_languages"
         resourceConfigurations.addAll(
diff --git a/app/k9mail/src/main/AndroidManifest.xml b/app/k9mail/src/main/AndroidManifest.xml
index 4bf1fc59b26725ab9dea17b711b5cc5ae1e40325..255834b4dc47efb5fb191be6b760e285534e519f 100644
--- a/app/k9mail/src/main/AndroidManifest.xml
+++ b/app/k9mail/src/main/AndroidManifest.xml
@@ -353,10 +353,6 @@
             android:name=".service.DatabaseUpgradeService"
             android:exported="false"/>
 
-        <service
-            android:name="com.fsck.k9.account.AccountRemoverService"
-            android:permission="android.permission.BIND_JOB_SERVICE"/>
-
         <service
             android:name=".controller.push.PushService"
             android:exported="false"
diff --git a/app/k9mail/src/main/java/com/fsck/k9/Dependencies.kt b/app/k9mail/src/main/java/com/fsck/k9/Dependencies.kt
index 9d95615bb0b2ead87f7edf29559c5db90ebb8bab..f2af6f00f325f7f283591edc7a32278cc00241ca 100644
--- a/app/k9mail/src/main/java/com/fsck/k9/Dependencies.kt
+++ b/app/k9mail/src/main/java/com/fsck/k9/Dependencies.kt
@@ -1,11 +1,18 @@
 package com.fsck.k9
 
+import app.k9mail.core.common.oauth.OAuthConfigurationFactory
+import app.k9mail.core.featureflag.FeatureFlagFactory
+import app.k9mail.core.featureflag.FeatureFlagProvider
+import app.k9mail.core.featureflag.InMemoryFeatureFlagProvider
 import app.k9mail.ui.widget.list.messageListWidgetModule
-import com.fsck.k9.auth.createOAuthConfigurationProvider
+import com.fsck.k9.account.newAccountModule
+import com.fsck.k9.auth.AppOAuthConfigurationFactory
 import com.fsck.k9.backends.backendsModule
 import com.fsck.k9.controller.ControllerExtension
 import com.fsck.k9.crypto.EncryptionExtractor
 import com.fsck.k9.crypto.openpgp.OpenPgpEncryptionExtractor
+import com.fsck.k9.feature.featureModule
+import com.fsck.k9.featureflag.InMemoryFeatureFlagFactory
 import com.fsck.k9.notification.notificationModule
 import com.fsck.k9.preferences.K9StoragePersister
 import com.fsck.k9.preferences.StoragePersister
@@ -29,7 +36,13 @@ private val mainAppModule = module {
     single(named("controllerExtensions")) { emptyList<ControllerExtension>() }
     single<EncryptionExtractor> { OpenPgpEncryptionExtractor.newInstance() }
     single<StoragePersister> { K9StoragePersister(get()) }
-    single { createOAuthConfigurationProvider() }
+    single<OAuthConfigurationFactory> { AppOAuthConfigurationFactory() }
+    single<FeatureFlagFactory> { InMemoryFeatureFlagFactory() }
+    single<FeatureFlagProvider> {
+        InMemoryFeatureFlagProvider(
+            featureFlagFactory = get(),
+        )
+    }
 }
 
 val appModules = listOf(
@@ -41,4 +54,6 @@ val appModules = listOf(
     resourcesModule,
     backendsModule,
     storageModule,
+    newAccountModule,
+    featureModule,
 )
diff --git a/app/k9mail/src/main/java/com/fsck/k9/account/AccountCreator.kt b/app/k9mail/src/main/java/com/fsck/k9/account/AccountCreator.kt
new file mode 100644
index 0000000000000000000000000000000000000000..1602f8ca4b318a2c296e378f993fe62dc1a3d75b
--- /dev/null
+++ b/app/k9mail/src/main/java/com/fsck/k9/account/AccountCreator.kt
@@ -0,0 +1,88 @@
+package com.fsck.k9.account
+
+import android.content.Context
+import app.k9mail.core.common.mail.Protocols
+import app.k9mail.feature.account.setup.AccountSetupExternalContract
+import app.k9mail.feature.account.setup.AccountSetupExternalContract.AccountCreator.AccountCreatorResult
+import app.k9mail.feature.account.setup.domain.entity.Account
+import com.fsck.k9.Account.FolderMode
+import com.fsck.k9.Core
+import com.fsck.k9.Preferences
+import com.fsck.k9.logging.Timber
+import com.fsck.k9.mail.store.imap.ImapStoreSettings.autoDetectNamespace
+import com.fsck.k9.mail.store.imap.ImapStoreSettings.createExtra
+import com.fsck.k9.mail.store.imap.ImapStoreSettings.isSendClientId
+import com.fsck.k9.mail.store.imap.ImapStoreSettings.isUseCompression
+import com.fsck.k9.mail.store.imap.ImapStoreSettings.pathPrefix
+import com.fsck.k9.mailstore.SpecialLocalFoldersCreator
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+class AccountCreator(
+    private val accountCreatorHelper: AccountCreatorHelper,
+    private val localFoldersCreator: SpecialLocalFoldersCreator,
+    private val preferences: Preferences,
+    private val context: Context,
+    private val coroutineDispatcher: CoroutineDispatcher = Dispatchers.IO,
+) : AccountSetupExternalContract.AccountCreator {
+
+    @Suppress("TooGenericExceptionCaught")
+    override suspend fun createAccount(account: Account): AccountCreatorResult {
+        return try {
+            withContext(coroutineDispatcher) { AccountCreatorResult.Success(create(account)) }
+        } catch (e: Exception) {
+            Timber.e(e, "Error while creating new account")
+
+            AccountCreatorResult.Error(e.message ?: "Unknown create account error")
+        }
+    }
+
+    private fun create(account: Account): String {
+        val newAccount = preferences.newAccount()
+
+        newAccount.email = account.emailAddress
+
+        val incomingServerSettings = account.incomingServerSettings
+        if (incomingServerSettings.type == Protocols.IMAP) {
+            newAccount.useCompression = incomingServerSettings.isUseCompression
+            newAccount.isSendClientIdEnabled = incomingServerSettings.isSendClientId
+            newAccount.incomingServerSettings = incomingServerSettings.copy(
+                extra = createExtra(
+                    autoDetectNamespace = incomingServerSettings.autoDetectNamespace,
+                    pathPrefix = incomingServerSettings.pathPrefix,
+                ),
+            )
+        } else {
+            newAccount.incomingServerSettings = incomingServerSettings
+        }
+
+        newAccount.outgoingServerSettings = account.outgoingServerSettings
+
+        newAccount.oAuthState = account.authorizationState
+
+        newAccount.name = account.options.accountName
+        newAccount.senderName = account.options.displayName
+        if (account.options.emailSignature != null) {
+            newAccount.signatureUse = true
+            newAccount.signature = account.options.emailSignature
+        }
+        newAccount.isNotifyNewMail = account.options.showNotification
+        newAccount.automaticCheckIntervalMinutes = account.options.checkFrequencyInMinutes
+        newAccount.displayCount = account.options.messageDisplayCount
+
+        newAccount.folderPushMode = FolderMode.NONE
+        newAccount.deletePolicy = accountCreatorHelper.getDefaultDeletePolicy(incomingServerSettings.type)
+        newAccount.chipColor = accountCreatorHelper.pickColor()
+
+        localFoldersCreator.createSpecialLocalFolders(newAccount)
+
+        newAccount.markSetupFinished()
+
+        preferences.saveAccount(newAccount)
+
+        Core.setServicesEnabled(context)
+
+        return newAccount.uuid
+    }
+}
diff --git a/app/k9mail/src/main/java/com/fsck/k9/account/AccountModule.kt b/app/k9mail/src/main/java/com/fsck/k9/account/AccountModule.kt
new file mode 100644
index 0000000000000000000000000000000000000000..e1a250f68d6004aca73953940d71ea8da8ebf135
--- /dev/null
+++ b/app/k9mail/src/main/java/com/fsck/k9/account/AccountModule.kt
@@ -0,0 +1,22 @@
+package com.fsck.k9.account
+
+import app.k9mail.feature.account.setup.AccountSetupExternalContract
+import org.koin.android.ext.koin.androidApplication
+import org.koin.dsl.module
+
+val newAccountModule = module {
+    factory<AccountSetupExternalContract.AccountOwnerNameProvider> {
+        AccountOwnerNameProvider(
+            preferences = get(),
+        )
+    }
+
+    factory<AccountSetupExternalContract.AccountCreator> {
+        AccountCreator(
+            accountCreatorHelper = get(),
+            localFoldersCreator = get(),
+            preferences = get(),
+            context = androidApplication(),
+        )
+    }
+}
diff --git a/app/k9mail/src/main/java/com/fsck/k9/account/AccountOwnerNameProvider.kt b/app/k9mail/src/main/java/com/fsck/k9/account/AccountOwnerNameProvider.kt
new file mode 100644
index 0000000000000000000000000000000000000000..8a66c9dad62aea7f6af088c00a20a4b6e549c434
--- /dev/null
+++ b/app/k9mail/src/main/java/com/fsck/k9/account/AccountOwnerNameProvider.kt
@@ -0,0 +1,18 @@
+package com.fsck.k9.account
+
+import app.k9mail.feature.account.setup.AccountSetupExternalContract
+import com.fsck.k9.Preferences
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+class AccountOwnerNameProvider(
+    private val preferences: Preferences,
+    private val coroutineDispatcher: CoroutineDispatcher = Dispatchers.IO,
+) : AccountSetupExternalContract.AccountOwnerNameProvider {
+    override suspend fun getOwnerName(): String? {
+        return withContext(coroutineDispatcher) {
+            preferences.defaultAccount?.senderName
+        }
+    }
+}
diff --git a/app/k9mail/src/main/java/com/fsck/k9/auth/AppOAuthConfigurationFactory.kt b/app/k9mail/src/main/java/com/fsck/k9/auth/AppOAuthConfigurationFactory.kt
new file mode 100644
index 0000000000000000000000000000000000000000..0116365aeb0bac16d12bc0ed9f51105996460e02
--- /dev/null
+++ b/app/k9mail/src/main/java/com/fsck/k9/auth/AppOAuthConfigurationFactory.kt
@@ -0,0 +1,71 @@
+package com.fsck.k9.auth
+
+import app.k9mail.core.common.oauth.OAuthConfiguration
+import app.k9mail.core.common.oauth.OAuthConfigurationFactory
+import com.fsck.k9.BuildConfig
+
+class AppOAuthConfigurationFactory : OAuthConfigurationFactory {
+    override fun createConfigurations(): Map<List<String>, OAuthConfiguration> {
+        return mapOf(
+            createAolConfiguration(),
+            createGmailConfiguration(),
+            createMicrosoftConfiguration(),
+            createYahooConfiguration(),
+        )
+    }
+
+    private fun createAolConfiguration(): Pair<List<String>, OAuthConfiguration> {
+        return listOf("imap.aol.com", "smtp.aol.com") to OAuthConfiguration(
+            clientId = BuildConfig.OAUTH_AOL_CLIENT_ID,
+            scopes = listOf("mail-w"),
+            authorizationEndpoint = "https://api.login.aol.com/oauth2/request_auth",
+            tokenEndpoint = "https://api.login.aol.com/oauth2/get_token",
+            redirectUri = "${BuildConfig.APPLICATION_ID}://oauth2redirect",
+        )
+    }
+
+    private fun createGmailConfiguration(): Pair<List<String>, OAuthConfiguration> {
+        return listOf(
+            "imap.gmail.com",
+            "imap.googlemail.com",
+            "smtp.gmail.com",
+            "smtp.googlemail.com",
+        ) to OAuthConfiguration(
+            clientId = BuildConfig.OAUTH_GMAIL_CLIENT_ID,
+            scopes = listOf("https://mail.google.com/"),
+            authorizationEndpoint = "https://accounts.google.com/o/oauth2/v2/auth",
+            tokenEndpoint = "https://oauth2.googleapis.com/token",
+            redirectUri = "${BuildConfig.APPLICATION_ID}:/oauth2redirect",
+        )
+    }
+
+    private fun createMicrosoftConfiguration(): Pair<List<String>, OAuthConfiguration> {
+        return listOf(
+            "outlook.office365.com",
+            "smtp.office365.com",
+        ) to OAuthConfiguration(
+            clientId = BuildConfig.OAUTH_MICROSOFT_CLIENT_ID,
+            scopes = listOf(
+                "https://outlook.office.com/IMAP.AccessAsUser.All",
+                "https://outlook.office.com/SMTP.Send",
+                "offline_access",
+            ),
+            authorizationEndpoint = "https://login.microsoftonline.com/common/oauth2/v2.0/authorize",
+            tokenEndpoint = "https://login.microsoftonline.com/common/oauth2/v2.0/token",
+            redirectUri = BuildConfig.OAUTH_MICROSOFT_REDIRECT_URI,
+        )
+    }
+
+    private fun createYahooConfiguration(): Pair<List<String>, OAuthConfiguration> {
+        return listOf(
+            "imap.mail.yahoo.com",
+            "smtp.mail.yahoo.com",
+        ) to OAuthConfiguration(
+            clientId = BuildConfig.OAUTH_YAHOO_CLIENT_ID,
+            scopes = listOf("mail-w"),
+            authorizationEndpoint = "https://api.login.yahoo.com/oauth2/request_auth",
+            tokenEndpoint = "https://api.login.yahoo.com/oauth2/get_token",
+            redirectUri = "${BuildConfig.APPLICATION_ID}://oauth2redirect",
+        )
+    }
+}
diff --git a/app/k9mail/src/main/java/com/fsck/k9/auth/OAuthConfigurations.kt b/app/k9mail/src/main/java/com/fsck/k9/auth/OAuthConfigurations.kt
deleted file mode 100644
index 78456bdf9eb1355e811659663968d074d65946be..0000000000000000000000000000000000000000
--- a/app/k9mail/src/main/java/com/fsck/k9/auth/OAuthConfigurations.kt
+++ /dev/null
@@ -1,50 +0,0 @@
-package com.fsck.k9.auth
-
-import com.fsck.k9.BuildConfig
-import com.fsck.k9.oauth.OAuthConfiguration
-import com.fsck.k9.oauth.OAuthConfigurationProvider
-
-fun createOAuthConfigurationProvider(): OAuthConfigurationProvider {
-    val redirectUriSlash = BuildConfig.APPLICATION_ID + ":/oauth2redirect"
-    val redirectUriDoubleSlash = BuildConfig.APPLICATION_ID + "://oauth2redirect"
-
-    val googleConfig = OAuthConfiguration(
-        clientId = BuildConfig.OAUTH_GMAIL_CLIENT_ID,
-        scopes = listOf("https://mail.google.com/"),
-        authorizationEndpoint = "https://accounts.google.com/o/oauth2/v2/auth",
-        tokenEndpoint = "https://oauth2.googleapis.com/token",
-        redirectUri = redirectUriSlash,
-    )
-
-    return OAuthConfigurationProvider(
-        configurations = mapOf(
-            listOf("imap.gmail.com", "imap.googlemail.com", "smtp.gmail.com", "smtp.googlemail.com") to googleConfig,
-            listOf("imap.mail.yahoo.com", "smtp.mail.yahoo.com") to OAuthConfiguration(
-                clientId = BuildConfig.OAUTH_YAHOO_CLIENT_ID,
-                scopes = listOf("mail-w"),
-                authorizationEndpoint = "https://api.login.yahoo.com/oauth2/request_auth",
-                tokenEndpoint = "https://api.login.yahoo.com/oauth2/get_token",
-                redirectUri = redirectUriDoubleSlash,
-            ),
-            listOf("imap.aol.com", "smtp.aol.com") to OAuthConfiguration(
-                clientId = BuildConfig.OAUTH_AOL_CLIENT_ID,
-                scopes = listOf("mail-w"),
-                authorizationEndpoint = "https://api.login.aol.com/oauth2/request_auth",
-                tokenEndpoint = "https://api.login.aol.com/oauth2/get_token",
-                redirectUri = redirectUriDoubleSlash,
-            ),
-            listOf("outlook.office365.com", "smtp.office365.com") to OAuthConfiguration(
-                clientId = BuildConfig.OAUTH_MICROSOFT_CLIENT_ID,
-                scopes = listOf(
-                    "https://outlook.office.com/IMAP.AccessAsUser.All",
-                    "https://outlook.office.com/SMTP.Send",
-                    "offline_access",
-                ),
-                authorizationEndpoint = "https://login.microsoftonline.com/common/oauth2/v2.0/authorize",
-                tokenEndpoint = "https://login.microsoftonline.com/common/oauth2/v2.0/token",
-                redirectUri = BuildConfig.OAUTH_MICROSOFT_REDIRECT_URI,
-            ),
-        ),
-        googleConfiguration = googleConfig,
-    )
-}
diff --git a/app/k9mail/src/main/java/com/fsck/k9/backends/AccountAuthStateStorage.kt b/app/k9mail/src/main/java/com/fsck/k9/backends/AccountAuthStateStorage.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d7610713ba34edb4fbaf37f1b6fa9b2e75a9a5f7
--- /dev/null
+++ b/app/k9mail/src/main/java/com/fsck/k9/backends/AccountAuthStateStorage.kt
@@ -0,0 +1,23 @@
+package com.fsck.k9.backends
+
+import com.fsck.k9.Account
+import com.fsck.k9.mail.oauth.AuthStateStorage
+import com.fsck.k9.preferences.AccountManager
+
+class AccountAuthStateStorage(
+    private val accountManager: AccountManager,
+    private val account: Account,
+) : AuthStateStorage {
+    override fun getAuthorizationState(): String? {
+        return account.oAuthState
+    }
+
+    override fun updateAuthorizationState(authorizationState: String?) {
+        account.oAuthState = authorizationState
+        accountManager.saveAccount(account)
+    }
+
+    override fun getEmail(): String? {
+        return account.email
+    }
+}
diff --git a/app/k9mail/src/main/java/com/fsck/k9/backends/ImapBackendFactory.kt b/app/k9mail/src/main/java/com/fsck/k9/backends/ImapBackendFactory.kt
index 5d8dab8ef7808ec0fb30044ed21e97a5da10f6a7..62942df1b252060eae959e6a614f2b61e9f6116c 100644
--- a/app/k9mail/src/main/java/com/fsck/k9/backends/ImapBackendFactory.kt
+++ b/app/k9mail/src/main/java/com/fsck/k9/backends/ImapBackendFactory.kt
@@ -2,7 +2,6 @@ package com.fsck.k9.backends
 
 import android.content.Context
 import com.fsck.k9.Account
-import com.fsck.k9.BuildConfig
 import com.fsck.k9.backend.BackendFactory
 import com.fsck.k9.backend.api.Backend
 import com.fsck.k9.backend.imap.ImapBackend
@@ -27,6 +26,7 @@ class ImapBackendFactory(
     private val backendStorageFactory: K9BackendStorageFactory,
     private val trustedSocketFactory: TrustedSocketFactory,
     private val context: Context,
+    private val clientIdAppName: String,
 ) : BackendFactory {
     override fun createBackend(account: Account): Backend {
         val accountName = account.displayName
@@ -47,15 +47,17 @@ class ImapBackendFactory(
     }
 
     private fun createImapStore(account: Account): ImapStore {
-        val oAuth2TokenProvider = if (account.incomingServerSettings.authenticationType == AuthType.XOAUTH2) {
-            RealOAuth2TokenProvider(context, accountManager, account)
+        val serverSettings = account.toImapServerSettings()
+
+        val oAuth2TokenProvider = if (serverSettings.authenticationType == AuthType.XOAUTH2) {
+            createOAuth2TokenProvider(account)
         } else {
             null
         }
 
         val config = createImapStoreConfig(account)
         return ImapStore.create(
-            account.incomingServerSettings,
+            serverSettings,
             config,
             trustedSocketFactory,
             oAuth2TokenProvider,
@@ -69,17 +71,14 @@ class ImapBackendFactory(
 
             override fun isSubscribedFoldersOnly() = account.isSubscribedFoldersOnly
 
-            override fun useCompression() = account.useCompression
-            override fun clientIdAppName(): String? {
-                return BuildConfig.CLIENT_ID_APP_NAME.takeIf { account.isSendClientIdEnabled }
-            }
+            override fun clientIdAppName() = clientIdAppName
         }
     }
 
     private fun createSmtpTransport(account: Account): SmtpTransport {
         val serverSettings = account.outgoingServerSettings
         val oauth2TokenProvider = if (serverSettings.authenticationType == AuthType.XOAUTH2) {
-            RealOAuth2TokenProvider(context, accountManager, account)
+            createOAuth2TokenProvider(account)
         } else {
             null
         }
@@ -87,6 +86,11 @@ class ImapBackendFactory(
         return SmtpTransport(serverSettings, trustedSocketFactory, oauth2TokenProvider)
     }
 
+    private fun createOAuth2TokenProvider(account: Account): RealOAuth2TokenProvider {
+        val authStateStorage = AccountAuthStateStorage(accountManager, account)
+        return RealOAuth2TokenProvider(context, authStateStorage)
+    }
+
     private fun createPushConfigProvider(account: Account) = object : ImapPushConfigProvider {
         override val maxPushFoldersFlow: Flow<Int>
             get() = accountManager.getAccountFlow(account.uuid)
diff --git a/app/k9mail/src/main/java/com/fsck/k9/backends/ImapServerSettingsExtensions.kt b/app/k9mail/src/main/java/com/fsck/k9/backends/ImapServerSettingsExtensions.kt
new file mode 100644
index 0000000000000000000000000000000000000000..b96fdf63e89935b649ea010f311b6074fde2322f
--- /dev/null
+++ b/app/k9mail/src/main/java/com/fsck/k9/backends/ImapServerSettingsExtensions.kt
@@ -0,0 +1,19 @@
+package com.fsck.k9.backends
+
+import com.fsck.k9.Account
+import com.fsck.k9.mail.ServerSettings
+import com.fsck.k9.mail.store.imap.ImapStoreSettings
+import com.fsck.k9.mail.store.imap.ImapStoreSettings.autoDetectNamespace
+import com.fsck.k9.mail.store.imap.ImapStoreSettings.pathPrefix
+
+fun Account.toImapServerSettings(): ServerSettings {
+    val serverSettings = incomingServerSettings
+    return serverSettings.copy(
+        extra = ImapStoreSettings.createExtra(
+            autoDetectNamespace = serverSettings.autoDetectNamespace,
+            pathPrefix = serverSettings.pathPrefix,
+            useCompression = useCompression,
+            sendClientId = isSendClientIdEnabled,
+        ),
+    )
+}
diff --git a/app/k9mail/src/main/java/com/fsck/k9/backends/KoinModule.kt b/app/k9mail/src/main/java/com/fsck/k9/backends/KoinModule.kt
index 9e08e9978b0f0f1aff47c66c2952e5b75a03da10..99a976f83635c248a89b79378b4b2dbdafa1d73e 100644
--- a/app/k9mail/src/main/java/com/fsck/k9/backends/KoinModule.kt
+++ b/app/k9mail/src/main/java/com/fsck/k9/backends/KoinModule.kt
@@ -2,10 +2,13 @@ package com.fsck.k9.backends
 
 import app.k9mail.dev.developmentBackends
 import app.k9mail.dev.developmentModuleAdditions
+import com.fsck.k9.BuildConfig
 import com.fsck.k9.backend.BackendManager
 import com.fsck.k9.backend.imap.BackendIdleRefreshManager
 import com.fsck.k9.backend.imap.SystemAlarmManager
+import com.fsck.k9.mail.oauth.OAuth2TokenProviderFactory
 import com.fsck.k9.mail.store.imap.IdleRefreshManager
+import org.koin.core.qualifier.named
 import org.koin.dsl.module
 
 val backendsModule = module {
@@ -25,11 +28,14 @@ val backendsModule = module {
             backendStorageFactory = get(),
             trustedSocketFactory = get(),
             context = get(),
+            clientIdAppName = get(named("ClientIdAppName")),
         )
     }
     single<SystemAlarmManager> { AndroidAlarmManager(context = get(), alarmManager = get()) }
     single<IdleRefreshManager> { BackendIdleRefreshManager(alarmManager = get()) }
     single { Pop3BackendFactory(get(), get()) }
+    single(named("ClientIdAppName")) { BuildConfig.CLIENT_ID_APP_NAME }
+    single<OAuth2TokenProviderFactory> { RealOAuth2TokenProviderFactory(context = get()) }
 
     developmentModuleAdditions()
 }
diff --git a/app/k9mail/src/main/java/com/fsck/k9/backends/RealOAuth2TokenProvider.kt b/app/k9mail/src/main/java/com/fsck/k9/backends/RealOAuth2TokenProvider.kt
index ed65f485a15d297f3446ecb7dfca887b1b24fe45..93397e846269fdc40b204127dde0b93dc4584950 100644
--- a/app/k9mail/src/main/java/com/fsck/k9/backends/RealOAuth2TokenProvider.kt
+++ b/app/k9mail/src/main/java/com/fsck/k9/backends/RealOAuth2TokenProvider.kt
@@ -1,10 +1,10 @@
 package com.fsck.k9.backends
 
 import android.content.Context
-import com.fsck.k9.Account
+import com.fsck.k9.BuildConfig
 import com.fsck.k9.mail.AuthenticationFailedException
+import com.fsck.k9.mail.oauth.AuthStateStorage
 import com.fsck.k9.mail.oauth.OAuth2TokenProvider
-import com.fsck.k9.preferences.AccountManager
 import com.fsck.k9.setup.EeloAccountHelper
 import java.io.IOException
 import java.util.concurrent.CountDownLatch
@@ -14,30 +14,32 @@ import net.openid.appauth.AuthorizationException
 import net.openid.appauth.AuthorizationException.AuthorizationRequestErrors
 import net.openid.appauth.AuthorizationException.GeneralErrors
 import net.openid.appauth.AuthorizationService
+import timber.log.Timber
 
 class RealOAuth2TokenProvider(
     private val context: Context,
-    private val accountManager: AccountManager,
-    private val account: Account,
+    private val authStateStorage: AuthStateStorage,
 ) : OAuth2TokenProvider {
 
     private val authService = AuthorizationService(context)
     private var requestFreshToken = false
 
-    override fun getToken(email: String, timeoutMillis: Long): String {
+    @Suppress("TooGenericExceptionCaught")
+    override fun getToken(timeoutMillis: Long): String {
         // if the authState is retrieved from accountManager, then return it. Refresh will be handled by accountManager.
-        if (EeloAccountHelper.updateOAuthState(context, accountManager, account)) {
-            return account.oAuthState?.let { AuthState.jsonDeserialize(it) }?.accessToken
+        if (EeloAccountHelper.updateOAuthState(context, authStateStorage)) {
+            return authStateStorage.getAuthorizationState()?.let { AuthState.jsonDeserialize(it) }?.accessToken
                 ?: throw AuthenticationFailedException("Login required")
         }
 
-        val accountManagerAccount = EeloAccountHelper.retrieveOpenIdAccountFromAccountManager(context, email)
+        val accountManagerAccount =
+            EeloAccountHelper.retrieveOpenIdAccountFromAccountManager(context, authStateStorage.getEmail())
 
         val latch = CountDownLatch(1)
         var token: String? = null
         var exception: AuthorizationException? = null
 
-        val authState = account.oAuthState?.let { AuthState.jsonDeserialize(it) }
+        val authState = authStateStorage.getAuthorizationState()?.let { AuthState.jsonDeserialize(it) }
             ?: throw AuthenticationFailedException("Login required")
 
         if (requestFreshToken) {
@@ -46,14 +48,30 @@ class RealOAuth2TokenProvider(
 
         val oldAccessToken = authState.accessToken
 
-        authState.performActionWithFreshTokens(authService) { accessToken: String?, _, authException: AuthorizationException? ->
-            token = accessToken
-            exception = authException
+        try {
+            authState.performActionWithFreshTokens(authService) { accessToken: String?, _, authException: AuthorizationException? ->
+                token = accessToken
+                exception = authException
 
-            latch.countDown()
-        }
+                latch.countDown()
+            }
+
+            latch.await(timeoutMillis, TimeUnit.MILLISECONDS)
+        } catch (e: Exception) {
+            // OAuth errors are communicated via the callback. If we end up here, it's probably a programming error.
+            if (BuildConfig.DEBUG) {
+                throw AssertionError("Wrong usage of AuthState.performActionWithFreshTokens()?", e)
+            }
+
+            Timber.w(e, "Failed to fetch an access token. Clearing authorization state.")
 
-        latch.await(timeoutMillis, TimeUnit.MILLISECONDS)
+            authStateStorage.updateAuthorizationState(authorizationState = null)
+
+            throw AuthenticationFailedException(
+                message = "Failed to fetch an access token",
+                throwable = e,
+            )
+        }
 
         val authException = exception
         if (authException == GeneralErrors.NETWORK_ERROR ||
@@ -63,8 +81,8 @@ class RealOAuth2TokenProvider(
         ) {
             throw IOException("Error while fetching an access token", authException)
         } else if (authException != null) {
-            account.oAuthState = null
-            accountManager.saveAccount(account)
+            authStateStorage.updateAuthorizationState(authorizationState = null)
+
             throw AuthenticationFailedException(
                 message = "Failed to fetch an access token",
                 throwable = authException,
@@ -72,13 +90,12 @@ class RealOAuth2TokenProvider(
             )
         } else if (token != oldAccessToken) {
             requestFreshToken = false
-            account.oAuthState = authState.jsonSerializeString()
-            accountManager.saveAccount(account)
+            authStateStorage.updateAuthorizationState(authorizationState = authState.jsonSerializeString())
             EeloAccountHelper.updateAccountInAccountManager(
                 context,
                 accountManagerAccount,
                 authState.jsonSerializeString(),
-                authState.accessToken
+                authState.accessToken,
             )
         }
 
diff --git a/app/k9mail/src/main/java/com/fsck/k9/backends/RealOAuth2TokenProviderFactory.kt b/app/k9mail/src/main/java/com/fsck/k9/backends/RealOAuth2TokenProviderFactory.kt
new file mode 100644
index 0000000000000000000000000000000000000000..58401172decb47bb5ce4d4a0f4eb279ce847bbb7
--- /dev/null
+++ b/app/k9mail/src/main/java/com/fsck/k9/backends/RealOAuth2TokenProviderFactory.kt
@@ -0,0 +1,14 @@
+package com.fsck.k9.backends
+
+import android.content.Context
+import com.fsck.k9.mail.oauth.AuthStateStorage
+import com.fsck.k9.mail.oauth.OAuth2TokenProvider
+import com.fsck.k9.mail.oauth.OAuth2TokenProviderFactory
+
+class RealOAuth2TokenProviderFactory(
+    private val context: Context,
+) : OAuth2TokenProviderFactory {
+    override fun create(authStateStorage: AuthStateStorage): OAuth2TokenProvider {
+        return RealOAuth2TokenProvider(context, authStateStorage)
+    }
+}
diff --git a/app/k9mail/src/main/java/com/fsck/k9/feature/AccountSetupFinishedLauncher.kt b/app/k9mail/src/main/java/com/fsck/k9/feature/AccountSetupFinishedLauncher.kt
new file mode 100644
index 0000000000000000000000000000000000000000..2578f76d6a2613ff74af4fc8af745e86a62bd381
--- /dev/null
+++ b/app/k9mail/src/main/java/com/fsck/k9/feature/AccountSetupFinishedLauncher.kt
@@ -0,0 +1,21 @@
+package com.fsck.k9.feature
+
+import android.content.Context
+import android.content.Intent
+import app.k9mail.feature.launcher.FeatureLauncherExternalContract
+import com.fsck.k9.activity.MessageList
+
+class AccountSetupFinishedLauncher(
+    private val context: Context,
+) : FeatureLauncherExternalContract.AccountSetupFinishedLauncher {
+    override fun launch(accountUuid: String) {
+        val intent = Intent(context, MessageList::class.java).apply {
+            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+            addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK)
+            addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
+            putExtra(MessageList.EXTRA_ACCOUNT, accountUuid)
+        }
+
+        context.startActivity(intent)
+    }
+}
diff --git a/app/k9mail/src/main/java/com/fsck/k9/feature/FeatureModule.kt b/app/k9mail/src/main/java/com/fsck/k9/feature/FeatureModule.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c0aa8a943fa806b5bccf60b46cd9d9606b0e1464
--- /dev/null
+++ b/app/k9mail/src/main/java/com/fsck/k9/feature/FeatureModule.kt
@@ -0,0 +1,19 @@
+package com.fsck.k9.feature
+
+import app.k9mail.feature.launcher.FeatureLauncherExternalContract
+import org.koin.android.ext.koin.androidContext
+import org.koin.dsl.module
+
+val featureModule = module {
+    factory<FeatureLauncherExternalContract.AccountSetupFinishedLauncher> {
+        AccountSetupFinishedLauncher(
+            context = androidContext(),
+        )
+    }
+
+    factory<FeatureLauncherExternalContract.ImportSettingsLauncher> {
+        ImportSettingsLauncher(
+            context = androidContext(),
+        )
+    }
+}
diff --git a/app/k9mail/src/main/java/com/fsck/k9/feature/ImportSettingsLauncher.kt b/app/k9mail/src/main/java/com/fsck/k9/feature/ImportSettingsLauncher.kt
new file mode 100644
index 0000000000000000000000000000000000000000..45a5a778cace8ce3ae2a8b815f3f377f0e1c82ce
--- /dev/null
+++ b/app/k9mail/src/main/java/com/fsck/k9/feature/ImportSettingsLauncher.kt
@@ -0,0 +1,18 @@
+package com.fsck.k9.feature
+
+import android.content.Context
+import android.content.Intent
+import app.k9mail.feature.launcher.FeatureLauncherExternalContract
+import com.fsck.k9.activity.FragmentLauncherActivity
+
+class ImportSettingsLauncher(
+    private val context: Context,
+) : FeatureLauncherExternalContract.ImportSettingsLauncher {
+    override fun launch() {
+        val intent = Intent(context, FragmentLauncherActivity::class.java).apply {
+            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+            putExtra(FragmentLauncherActivity.EXTRA_FRAGMENT, FragmentLauncherActivity.FRAGMENT_IMPORT_SETTINGS)
+        }
+        context.startActivity(intent)
+    }
+}
diff --git a/app/k9mail/src/main/java/com/fsck/k9/featureflag/InMemoryFeatureFlagFactory.kt b/app/k9mail/src/main/java/com/fsck/k9/featureflag/InMemoryFeatureFlagFactory.kt
new file mode 100644
index 0000000000000000000000000000000000000000..2c5eb849490a6a5424119ee5369f39ce72f00eb0
--- /dev/null
+++ b/app/k9mail/src/main/java/com/fsck/k9/featureflag/InMemoryFeatureFlagFactory.kt
@@ -0,0 +1,13 @@
+package com.fsck.k9.featureflag
+
+import app.k9mail.core.featureflag.FeatureFlag
+import app.k9mail.core.featureflag.FeatureFlagFactory
+import app.k9mail.core.featureflag.FeatureFlagKey
+
+class InMemoryFeatureFlagFactory : FeatureFlagFactory {
+    override fun createFeatureCatalog(): List<FeatureFlag> {
+        return listOf(
+            FeatureFlag(FeatureFlagKey("new_onboarding"), false),
+        )
+    }
+}
diff --git a/app/k9mail/src/main/java/com/fsck/k9/notification/K9NotificationResourceProvider.kt b/app/k9mail/src/main/java/com/fsck/k9/notification/K9NotificationResourceProvider.kt
index 55e1584d2a55d62caadcab31c75d9161408ec4f8..90df7f176d12339ff957dc40431465b18018d883 100644
--- a/app/k9mail/src/main/java/com/fsck/k9/notification/K9NotificationResourceProvider.kt
+++ b/app/k9mail/src/main/java/com/fsck/k9/notification/K9NotificationResourceProvider.kt
@@ -11,6 +11,7 @@ class K9NotificationResourceProvider(private val context: Context) : Notificatio
     override val iconNewMail: Int = R.drawable.notification_icon_new_mail
     override val iconSendingMail: Int = R.drawable.notification_icon_check_mail
     override val iconCheckingMail: Int = R.drawable.notification_icon_check_mail
+    override val iconBackgroundWorkNotification: Int = R.drawable.notification_icon_background_work
     override val wearIconMarkAsRead: Int = R.drawable.notification_action_mark_as_read
     override val wearIconDelete: Int = R.drawable.notification_action_delete
     override val wearIconArchive: Int = R.drawable.notification_action_archive
diff --git a/app/k9mail/src/main/java/com/fsck/k9/notification/K9NotificationStrategy.kt b/app/k9mail/src/main/java/com/fsck/k9/notification/K9NotificationStrategy.kt
index 242569abf112c9e2c63e28b6c435c95a6703b5ab..005a8e125086890481b8d119c4ca26f4a7ea399d 100644
--- a/app/k9mail/src/main/java/com/fsck/k9/notification/K9NotificationStrategy.kt
+++ b/app/k9mail/src/main/java/com/fsck/k9/notification/K9NotificationStrategy.kt
@@ -1,7 +1,7 @@
 package com.fsck.k9.notification
 
 import app.k9mail.core.android.common.contact.ContactRepository
-import app.k9mail.core.common.mail.EmailAddress
+import app.k9mail.core.common.mail.toEmailAddressOrNull
 import com.fsck.k9.Account
 import com.fsck.k9.K9
 import com.fsck.k9.mail.Flag
@@ -88,7 +88,7 @@ class K9NotificationStrategy(
         }
 
         if (account.isNotifyContactsMailOnly &&
-            !contactRepository.hasAnyContactFor(message.from.asList().mapNotNull { EmailAddress(it.address) })
+            !contactRepository.hasAnyContactFor(message.from.asList().mapNotNull { it.address.toEmailAddressOrNull() })
         ) {
             Timber.v("No notification: Message is not from a known contact")
             return false
diff --git a/app/k9mail/src/test/java/com/fsck/k9/DependencyInjectionTest.kt b/app/k9mail/src/test/java/com/fsck/k9/DependencyInjectionTest.kt
index fbc3c135f4eb0b9ae96311f7f4090759d8c78437..636d824ab02d66cb7e8e0c93eefcee4cfe8ebd30 100644
--- a/app/k9mail/src/test/java/com/fsck/k9/DependencyInjectionTest.kt
+++ b/app/k9mail/src/test/java/com/fsck/k9/DependencyInjectionTest.kt
@@ -3,7 +3,12 @@ package com.fsck.k9
 import android.view.ContextThemeWrapper
 import androidx.lifecycle.LifecycleOwner
 import androidx.work.WorkerParameters
+import app.k9mail.feature.account.setup.domain.DomainContract.UseCase.ValidateServerSettings
+import app.k9mail.feature.account.setup.ui.validation.AccountValidationContract
+import com.fsck.k9.account.AccountRemoverWorker
 import com.fsck.k9.job.MailSyncWorker
+import com.fsck.k9.mail.oauth.AuthStateStorage
+import com.fsck.k9.ui.R
 import com.fsck.k9.ui.changelog.ChangeLogMode
 import com.fsck.k9.ui.changelog.ChangelogViewModel
 import com.fsck.k9.ui.endtoend.AutocryptKeyTransferActivity
@@ -16,6 +21,7 @@ import org.junit.runner.RunWith
 import org.koin.core.annotation.KoinInternalApi
 import org.koin.core.logger.PrintLogger
 import org.koin.core.parameter.parametersOf
+import org.koin.core.qualifier.named
 import org.koin.java.KoinJavaComponent
 import org.koin.test.AutoCloseKoinTest
 import org.koin.test.check.checkModules
@@ -33,6 +39,7 @@ class DependencyInjectionTest : AutoCloseKoinTest() {
         on { lifecycle } doReturn mock()
     }
     private val autocryptTransferView = mock<AutocryptKeyTransferActivity>()
+    private val authStateStorage = mock<AuthStateStorage>()
 
     @KoinInternalApi
     @Test
@@ -52,6 +59,10 @@ class DependencyInjectionTest : AutoCloseKoinTest() {
             withParameters(clazz = Class.forName("com.fsck.k9.view.K9WebViewClient").kotlin) {
                 parametersOf(null, null)
             }
+            withParameter<AccountValidationContract.ViewModel>(named("incoming_validation")) { authStateStorage }
+            withParameter<AccountValidationContract.ViewModel>(named("outgoing_validation")) { authStateStorage }
+            withParameter<ValidateServerSettings> { authStateStorage }
+            withParameter<AccountRemoverWorker> { mock<WorkerParameters>() }
         }
     }
 }
diff --git a/app/storage/src/main/java/com/fsck/k9/preferences/migrations/StorageMigrationTo14.kt b/app/storage/src/main/java/com/fsck/k9/preferences/migrations/StorageMigrationTo14.kt
index d82f4299327313a6252d2dc1e2ded35843f95bda..dd0ff249551d19865d51c34083b03d2aebb744e4 100644
--- a/app/storage/src/main/java/com/fsck/k9/preferences/migrations/StorageMigrationTo14.kt
+++ b/app/storage/src/main/java/com/fsck/k9/preferences/migrations/StorageMigrationTo14.kt
@@ -1,8 +1,8 @@
 package com.fsck.k9.preferences.migrations
 
 import android.database.sqlite.SQLiteDatabase
+import app.k9mail.core.common.mail.Protocols
 import com.fsck.k9.ServerSettingsSerializer
-import com.fsck.k9.preferences.Protocols
 
 /**
  * Rewrite 'folderPushMode' value of non-IMAP accounts to 'NONE'.
diff --git a/app/storage/src/main/java/com/fsck/k9/storage/migrations/MigrationTo65.kt b/app/storage/src/main/java/com/fsck/k9/storage/migrations/MigrationTo65.kt
index a93ed686bcf9758e65c0251eac45502b6be87670..0d4efc741db3ed35722e644689284cfc10d6b6f4 100644
--- a/app/storage/src/main/java/com/fsck/k9/storage/migrations/MigrationTo65.kt
+++ b/app/storage/src/main/java/com/fsck/k9/storage/migrations/MigrationTo65.kt
@@ -1,8 +1,8 @@
 package com.fsck.k9.storage.migrations
 
 import android.database.sqlite.SQLiteDatabase
+import app.k9mail.core.common.mail.Protocols
 import com.fsck.k9.mailstore.MigrationsHelper
-import com.fsck.k9.preferences.Protocols
 
 internal object MigrationTo65 {
     @JvmStatic
diff --git a/app/storage/src/main/java/com/fsck/k9/storage/migrations/MigrationTo76.kt b/app/storage/src/main/java/com/fsck/k9/storage/migrations/MigrationTo76.kt
index fa7b5f03427654926d812e8f6713feeed0d7eb67..6b1c97856a321bb465873229ca5c905660343f02 100644
--- a/app/storage/src/main/java/com/fsck/k9/storage/migrations/MigrationTo76.kt
+++ b/app/storage/src/main/java/com/fsck/k9/storage/migrations/MigrationTo76.kt
@@ -3,9 +3,9 @@ package com.fsck.k9.storage.migrations
 import android.content.ContentValues
 import android.database.sqlite.SQLiteDatabase
 import app.k9mail.core.android.common.database.map
+import app.k9mail.core.common.mail.Protocols
 import com.fsck.k9.Account
 import com.fsck.k9.mailstore.MigrationsHelper
-import com.fsck.k9.preferences.Protocols
 import timber.log.Timber
 
 /**
diff --git a/app/storage/src/test/java/com/fsck/k9/preferences/StoragePersisterTest.kt b/app/storage/src/test/java/com/fsck/k9/preferences/StoragePersisterTest.kt
index d54347151e6b96fecbb5c6f424d76ec0dd8a31f9..02417aecc6310641ebcbc0649707f8540e4cbbbd 100644
--- a/app/storage/src/test/java/com/fsck/k9/preferences/StoragePersisterTest.kt
+++ b/app/storage/src/test/java/com/fsck/k9/preferences/StoragePersisterTest.kt
@@ -1,13 +1,16 @@
 package com.fsck.k9.preferences
 
 import android.content.Context
+import assertk.assertFailure
+import assertk.assertThat
+import assertk.assertions.contains
+import assertk.assertions.containsOnly
+import assertk.assertions.isEmpty
+import assertk.assertions.isSameAs
+import assertk.assertions.isTrue
 import com.fsck.k9.preferences.K9StoragePersister.StoragePersistOperationCallback
 import com.fsck.k9.preferences.K9StoragePersister.StoragePersistOperations
 import com.fsck.k9.storage.K9RobolectricTest
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertSame
-import org.junit.Assert.assertTrue
-import org.junit.Assert.fail
 import org.junit.Test
 import org.mockito.kotlin.any
 import org.mockito.kotlin.inOrder
@@ -39,16 +42,15 @@ class StoragePersisterTest : K9RobolectricTest() {
         val operationCallback = prepareCallback(
             persistOp = { ops -> ops.put("x", "y") },
             onSuccess = { map ->
-                assertEquals(1, map.size)
-                assertEquals("y", map["x"])
+                assertThat(map).containsOnly("x" to "y")
             },
         )
 
         storagePersister.doInTransaction(operationCallback)
 
         val values = storagePersister.loadValues().all
-        assertEquals(1, values.size)
-        assertEquals("y", values["x"])
+
+        assertThat(values).containsOnly("x" to "y")
     }
 
     @Test
@@ -61,15 +63,13 @@ class StoragePersisterTest : K9RobolectricTest() {
             },
         )
 
-        try {
+        assertFailure {
             storagePersister.doInTransaction(operationCallback)
-            fail("expected exception")
-        } catch (e: Exception) {
-            assertSame(exception, e)
-        }
+        }.isSameAs(exception)
 
         val values = storagePersister.loadValues()
-        assertTrue(values.isEmpty())
+
+        assertThat(values.isEmpty).isTrue()
         verify(operationCallback, never()).onPersistTransactionSuccess(any())
     }
 
@@ -78,26 +78,32 @@ class StoragePersisterTest : K9RobolectricTest() {
         val operationCallback = prepareCallback(
             before = { map -> map["x"] = "y" },
             persistOp = { ops -> ops.remove("x") },
-            onSuccess = { map -> assertTrue(map.isEmpty()) },
+            onSuccess = { map ->
+                assertThat(map).isEmpty()
+            },
         )
 
         storagePersister.doInTransaction(operationCallback)
 
         val values = storagePersister.loadValues()
-        assertTrue(values.isEmpty())
+
+        assertThat(values.isEmpty).isTrue()
     }
 
     @Test
     fun doInTransaction_before_preserveButNotPersist() {
         val operationCallback = prepareCallback(
             before = { map -> map["x"] = "y" },
-            onSuccess = { map -> assertEquals("y", map["x"]) },
+            onSuccess = { map ->
+                assertThat(map).contains(key = "x", value = "y")
+            },
         )
 
         storagePersister.doInTransaction(operationCallback)
 
         val values = storagePersister.loadValues()
-        assertTrue(values.isEmpty())
+
+        assertThat(values.isEmpty).isTrue()
     }
 
     private fun prepareCallback(
diff --git a/app/storage/src/test/java/com/fsck/k9/storage/messages/ChunkedDatabaseOperationsTest.kt b/app/storage/src/test/java/com/fsck/k9/storage/messages/ChunkedDatabaseOperationsTest.kt
index 9c4814f0fd0167360e7d12e394acd22ac9c67a26..ba93095f269812489f45eb5b767a1b3565f7f99e 100644
--- a/app/storage/src/test/java/com/fsck/k9/storage/messages/ChunkedDatabaseOperationsTest.kt
+++ b/app/storage/src/test/java/com/fsck/k9/storage/messages/ChunkedDatabaseOperationsTest.kt
@@ -3,7 +3,7 @@ package com.fsck.k9.storage.messages
 import assertk.assertThat
 import assertk.assertions.hasSize
 import assertk.assertions.isEqualTo
-import org.junit.Assert.fail
+import assertk.fail
 import org.junit.Test
 
 class ChunkedDatabaseOperationsTest {
diff --git a/app/storage/src/test/java/com/fsck/k9/storage/messages/MoveMessageOperationsTest.kt b/app/storage/src/test/java/com/fsck/k9/storage/messages/MoveMessageOperationsTest.kt
index 9b79cc33422f4878e83469aeb1d4c4e2c5805226..8f85f08bf279f76d500e7f4a6b28c668b346f383 100644
--- a/app/storage/src/test/java/com/fsck/k9/storage/messages/MoveMessageOperationsTest.kt
+++ b/app/storage/src/test/java/com/fsck/k9/storage/messages/MoveMessageOperationsTest.kt
@@ -9,7 +9,6 @@ import assertk.assertions.startsWith
 import com.fsck.k9.K9
 import com.fsck.k9.storage.RobolectricTest
 import org.junit.Test
-import org.junit.Assert.fail as junitFail
 
 private const val SOURCE_FOLDER_ID = 3L
 private const val DESTINATION_FOLDER_ID = 23L
@@ -211,6 +210,4 @@ class MoveMessageOperationsTest : RobolectricTest() {
         assertThat(message.messagePartId).isNull()
         assertThat(message.encryptionType).isNull()
     }
-
-    private fun fail(message: String): Nothing = junitFail(message) as Nothing
 }
diff --git a/app/storage/src/test/java/com/fsck/k9/storage/messages/RetrieveFolderOperationsTest.kt b/app/storage/src/test/java/com/fsck/k9/storage/messages/RetrieveFolderOperationsTest.kt
index ea6c03913dcd3fcd5631b5265b3ae1ae3605c2ea..1dba4a96a2182f77b60a2c5b1a940e72fb1f75f5 100644
--- a/app/storage/src/test/java/com/fsck/k9/storage/messages/RetrieveFolderOperationsTest.kt
+++ b/app/storage/src/test/java/com/fsck/k9/storage/messages/RetrieveFolderOperationsTest.kt
@@ -1,10 +1,10 @@
 package com.fsck.k9.storage.messages
 
+import assertk.assertFailure
 import assertk.assertThat
 import assertk.assertions.hasSize
 import assertk.assertions.isEmpty
 import assertk.assertions.isEqualTo
-import assertk.assertions.isFailure
 import assertk.assertions.isInstanceOf
 import assertk.assertions.isNotNull
 import assertk.assertions.isNull
@@ -482,10 +482,9 @@ class RetrieveFolderOperationsTest : RobolectricTest() {
 
     @Test
     fun `get 'more messages' value from non-existent folder`() {
-        assertThat {
+        assertFailure {
             retrieveFolderOperations.hasMoreMessages(23)
-        }.isFailure()
-            .isInstanceOf(FolderNotFoundException::class)
+        }.isInstanceOf<FolderNotFoundException>()
             .transform { it.folderId }.isEqualTo(23)
     }
 
diff --git a/app/testing/build.gradle.kts b/app/testing/build.gradle.kts
index 036c1e009d63b86c582473126a0736719436eba3..3271ad754cda8bdebe7d1fde466a9e56fe7f8dd7 100644
--- a/app/testing/build.gradle.kts
+++ b/app/testing/build.gradle.kts
@@ -5,8 +5,8 @@ plugins {
 dependencies {
     implementation(projects.app.core)
 
-    api(libs.junit)
-    api(libs.robolectric)
+    api(projects.core.android.testing)
+
     api(libs.koin.core)
     api(libs.mockito.core)
     api(libs.mockito.kotlin)
diff --git a/app/ui/legacy/build.gradle.kts b/app/ui/legacy/build.gradle.kts
index 0eb61ffa8b5d6f8f271496b85f5f273b92a0d6de..d03fdd116c956e08ab0e8a81318989364f45feea 100644
--- a/app/ui/legacy/build.gradle.kts
+++ b/app/ui/legacy/build.gradle.kts
@@ -11,7 +11,11 @@ dependencies {
     implementation(projects.mail.common)
     implementation(projects.uiUtils.toolbarBottomSheet)
 
-    // Remove AccountSetupIncoming's dependency on these
+    implementation(projects.core.featureflags)
+    implementation(projects.feature.launcher)
+    // TODO: Remove AccountOauth dependency
+    implementation(projects.feature.account.oauth)
+
     compileOnly(projects.mail.protocols.imap)
 
     implementation(projects.plugins.openpgpApiLib.openpgpApi)
@@ -39,6 +43,7 @@ dependencies {
     implementation(libs.fastadapter.extensions.drag)
     implementation(libs.fastadapter.extensions.utils)
     implementation(libs.circleimageview)
+    implementation(libs.androidx.work.ktx)
     api(libs.appauth)
 
     implementation(libs.commons.io)
diff --git a/app/ui/legacy/src/main/AndroidManifest.xml b/app/ui/legacy/src/main/AndroidManifest.xml
index 31ddb8fb4f1bd790d2eaf57721510f69e4f3ebea..3699db3069288718324344bc6bf87c2fa4d42264 100644
--- a/app/ui/legacy/src/main/AndroidManifest.xml
+++ b/app/ui/legacy/src/main/AndroidManifest.xml
@@ -7,17 +7,21 @@
     <uses-permission android:name="android.permission.VIBRATE" />
 
     <application
-        android:theme="@style/Theme.MaterialComponents.NoActionBar.Bridge"
-        android:supportsRtl="true" />
+        android:supportsRtl="true"
+        android:theme="@style/Theme.MaterialComponents.NoActionBar.Bridge">
+
+        <activity android:name="com.fsck.k9.activity.FragmentLauncherActivity" />
+
+    </application>
 
     <queries>
         <intent>
             <!-- Used to check whether to display the "Add from Contacts" menu item in the compose screen -->
             <action android:name="android.intent.action.PICK" />
             <data
+                android:host="com.android.contacts"
                 android:mimeType="*/*"
-                android:scheme="content"
-                android:host="com.android.contacts" />
+                android:scheme="content" />
         </intent>
 
         <intent>
@@ -37,9 +41,9 @@
             <!-- Used by OpenPgpAppSelectDialog -->
             <action android:name="android.intent.action.VIEW" />
             <data
+                android:host="details"
                 android:mimeType="*/*"
-                android:scheme="market"
-                android:host="details" />
+                android:scheme="market" />
         </intent>
 
         <intent>
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/UiKoinModules.kt b/app/ui/legacy/src/main/java/com/fsck/k9/UiKoinModules.kt
index d1b3ae31374d1b7015b3bb4e1a315d4b67fed0f3..301848051d653e1ead1009f7232290aa28c9b437 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/UiKoinModules.kt
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/UiKoinModules.kt
@@ -1,6 +1,8 @@
 package com.fsck.k9
 
 import app.k9mail.autodiscovery.providersxml.autodiscoveryProvidersXmlModule
+import app.k9mail.feature.account.oauth.featureAccountOAuthModule
+import app.k9mail.feature.launcher.di.featureLauncherModule
 import com.fsck.k9.account.accountModule
 import com.fsck.k9.activity.activityModule
 import com.fsck.k9.contacts.contactsModule
@@ -21,6 +23,7 @@ import com.fsck.k9.ui.uiModule
 import com.fsck.k9.view.viewModule
 
 val uiModules = listOf(
+    featureAccountOAuthModule,
     uiBaseModule,
     activityModule,
     uiModule,
@@ -40,4 +43,5 @@ val uiModules = listOf(
     messageDetailsUiModule,
     messageViewUiModule,
     identityUiModule,
+    featureLauncherModule,
 )
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/account/AccountCreator.kt b/app/ui/legacy/src/main/java/com/fsck/k9/account/AccountCreatorHelper.kt
similarity index 94%
rename from app/ui/legacy/src/main/java/com/fsck/k9/account/AccountCreator.kt
rename to app/ui/legacy/src/main/java/com/fsck/k9/account/AccountCreatorHelper.kt
index 6fa0d0e22026f016310d1068c22c83d03f5ec4d5..88ed6c18ccf39bdd2096fe82c71473baddbe1dc7 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/account/AccountCreator.kt
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/account/AccountCreatorHelper.kt
@@ -1,18 +1,18 @@
 package com.fsck.k9.account
 
 import android.content.res.Resources
+import app.k9mail.core.common.mail.Protocols
 import com.fsck.k9.Account.DeletePolicy
 import com.fsck.k9.Preferences
 import com.fsck.k9.core.R
 import com.fsck.k9.mail.ConnectionSecurity
-import com.fsck.k9.preferences.Protocols
 
 /**
  * Deals with logic surrounding account creation.
  *
  * TODO Move much of the code from com.fsck.k9.activity.setup.* into here
  */
-class AccountCreator(private val preferences: Preferences, private val resources: Resources) {
+class AccountCreatorHelper(private val preferences: Preferences, private val resources: Resources) {
 
     fun getDefaultDeletePolicy(type: String): DeletePolicy {
         return when (type) {
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/account/AccountRemoverService.kt b/app/ui/legacy/src/main/java/com/fsck/k9/account/AccountRemoverService.kt
deleted file mode 100644
index 8482bde90ba0526fd681dc448080edf5931bc35d..0000000000000000000000000000000000000000
--- a/app/ui/legacy/src/main/java/com/fsck/k9/account/AccountRemoverService.kt
+++ /dev/null
@@ -1,34 +0,0 @@
-package com.fsck.k9.account
-
-import android.content.Context
-import android.content.Intent
-import androidx.core.app.JobIntentService
-import org.koin.core.component.KoinComponent
-import org.koin.core.component.inject
-
-/**
- * A [JobIntentService] to remove an account in the background.
- */
-class AccountRemoverService : JobIntentService(), KoinComponent {
-    private val accountRemover: AccountRemover by inject()
-
-    override fun onHandleWork(intent: Intent) {
-        val accountUuid = intent.getStringExtra(ARG_ACCOUNT_UUID)
-            ?: throw IllegalArgumentException("No account UUID provided")
-
-        accountRemover.removeAccount(accountUuid)
-    }
-
-    companion object {
-        private const val JOB_ID = 1
-        private const val ARG_ACCOUNT_UUID = "accountUuid"
-
-        fun enqueueRemoveAccountJob(context: Context, accountUuid: String) {
-            val workIntent = Intent().apply {
-                putExtra(ARG_ACCOUNT_UUID, accountUuid)
-            }
-
-            JobIntentService.enqueueWork(context, AccountRemoverService::class.java, JOB_ID, workIntent)
-        }
-    }
-}
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/account/AccountRemoverWorker.kt b/app/ui/legacy/src/main/java/com/fsck/k9/account/AccountRemoverWorker.kt
new file mode 100644
index 0000000000000000000000000000000000000000..19645f939043ca195544b39e2e20b83c7479de59
--- /dev/null
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/account/AccountRemoverWorker.kt
@@ -0,0 +1,55 @@
+package com.fsck.k9.account
+
+import android.content.Context
+import androidx.work.Data
+import androidx.work.ForegroundInfo
+import androidx.work.OneTimeWorkRequest
+import androidx.work.OutOfQuotaPolicy
+import androidx.work.WorkManager
+import androidx.work.Worker
+import androidx.work.WorkerParameters
+import com.fsck.k9.notification.BackgroundWorkNotificationController
+import com.fsck.k9.ui.R
+
+/**
+ * A [Worker] to remove an account in the background.
+ */
+class AccountRemoverWorker(
+    private val accountRemover: AccountRemover,
+    private val notificationController: BackgroundWorkNotificationController,
+    context: Context,
+    workerParams: WorkerParameters,
+) : Worker(context, workerParams) {
+
+    override fun doWork(): Result {
+        val accountUuid = requireNotNull(inputData.getString(ARG_ACCOUNT_UUID)) { "No account UUID provided" }
+
+        accountRemover.removeAccount(accountUuid)
+
+        return Result.success()
+    }
+
+    override fun getForegroundInfo(): ForegroundInfo {
+        val notificationText = applicationContext.getString(R.string.background_work_notification_remove_account)
+        val notificationId = notificationController.notificationId
+        val notification = notificationController.createNotification(notificationText)
+        return ForegroundInfo(notificationId, notification)
+    }
+
+    companion object {
+        private const val ARG_ACCOUNT_UUID = "accountUuid"
+
+        fun enqueueRemoveAccountWorker(context: Context, accountUuid: String) {
+            val data = Data.Builder()
+                .putString(ARG_ACCOUNT_UUID, accountUuid)
+                .build()
+
+            val request = OneTimeWorkRequest.Builder(AccountRemoverWorker::class.java)
+                .setExpedited(OutOfQuotaPolicy.RUN_AS_NON_EXPEDITED_WORK_REQUEST)
+                .setInputData(data)
+                .build()
+
+            WorkManager.getInstance(context).enqueue(request)
+        }
+    }
+}
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/account/BackgroundAccountRemover.kt b/app/ui/legacy/src/main/java/com/fsck/k9/account/BackgroundAccountRemover.kt
index 3bca002a03b2b9ef0e5374d713fb9b7835eca884..c4625e756edad86769a734a8c7ce9d7b9a5d2ed8 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/account/BackgroundAccountRemover.kt
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/account/BackgroundAccountRemover.kt
@@ -9,6 +9,6 @@ class BackgroundAccountRemover(private val context: Context) {
     fun removeAccountAsync(accountUuid: String) {
         // TODO: Add a mechanism to hide the account from the UI right away
 
-        AccountRemoverService.enqueueRemoveAccountJob(context, accountUuid)
+        AccountRemoverWorker.enqueueRemoveAccountWorker(context, accountUuid)
     }
 }
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/account/KoinModule.kt b/app/ui/legacy/src/main/java/com/fsck/k9/account/KoinModule.kt
index b25a3d8c2087d976026542addae22adf172307b1..75d13cc308c840589ea313351e21e63f15048d05 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/account/KoinModule.kt
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/account/KoinModule.kt
@@ -1,5 +1,6 @@
 package com.fsck.k9.account
 
+import androidx.work.WorkerParameters
 import org.koin.dsl.module
 
 val accountModule = module {
@@ -13,5 +14,8 @@ val accountModule = module {
         )
     }
     factory { BackgroundAccountRemover(get()) }
-    factory { AccountCreator(get(), get()) }
+    factory { AccountCreatorHelper(get(), get()) }
+    factory { (parameters: WorkerParameters) ->
+        AccountRemoverWorker(accountRemover = get(), notificationController = get(), context = get(), parameters)
+    }
 }
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/activity/FragmentLauncherActivity.kt b/app/ui/legacy/src/main/java/com/fsck/k9/activity/FragmentLauncherActivity.kt
new file mode 100644
index 0000000000000000000000000000000000000000..547a487e1fe88f2dba16f9eaf06be309a44b9027
--- /dev/null
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/activity/FragmentLauncherActivity.kt
@@ -0,0 +1,55 @@
+package com.fsck.k9.activity
+
+import android.content.Intent
+import android.os.Bundle
+import com.fsck.k9.ui.R
+import com.fsck.k9.ui.base.K9Activity
+import com.fsck.k9.ui.settings.import.SettingsImportFragment
+import com.fsck.k9.ui.settings.import.SettingsImportResultViewModel
+import com.fsck.k9.ui.settings.import.SettingsImportSuccess
+import org.koin.androidx.viewmodel.ext.android.viewModel
+
+class FragmentLauncherActivity : K9Activity() {
+
+    private val settingsImportResultViewModel: SettingsImportResultViewModel by viewModel()
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        setLayout(R.layout.activity_fragment_launcher)
+
+        when (val fragment = intent.getStringExtra(EXTRA_FRAGMENT)) {
+            FRAGMENT_IMPORT_SETTINGS -> setupSettingsFragment()
+            else -> throw IllegalArgumentException("Unknown destination: $fragment")
+        }
+    }
+
+    private fun setupSettingsFragment() {
+        setTitle(R.string.settings_import_title)
+        supportFragmentManager.beginTransaction()
+            .replace(R.id.fragment_launcher_container, SettingsImportFragment())
+            .commit()
+
+        settingsImportResultViewModel.settingsImportResult.observe(this) {
+            if (it == SettingsImportSuccess) {
+                launchMessageList()
+                finish()
+            }
+        }
+    }
+
+    private fun launchMessageList() {
+        val intent = Intent(this, MessageList::class.java).apply {
+            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+            addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK)
+            addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
+        }
+
+        startActivity(intent)
+    }
+
+    companion object {
+        const val EXTRA_FRAGMENT = "fragment"
+        const val FRAGMENT_IMPORT_SETTINGS = "import_settings"
+    }
+}
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/activity/KoinModule.kt b/app/ui/legacy/src/main/java/com/fsck/k9/activity/KoinModule.kt
index f1f970380c8df68a3cf63d82a8f762eecad09742..3663bc8dbf85bb8e128839564a2d05f2d3570992 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/activity/KoinModule.kt
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/activity/KoinModule.kt
@@ -6,5 +6,11 @@ import org.koin.dsl.module
 
 val activityModule = module {
     single { MessageLoaderHelperFactory(messageViewInfoExtractorFactory = get(), htmlSettingsProvider = get()) }
-    viewModel { AuthViewModel(application = get(), accountManager = get(), oAuthConfigurationProvider = get()) }
+    viewModel {
+        AuthViewModel(
+            application = get(),
+            accountManager = get(),
+            getOAuthRequestIntent = get(),
+        )
+    }
 }
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/activity/MessageCompose.java b/app/ui/legacy/src/main/java/com/fsck/k9/activity/MessageCompose.java
index 4afd187b6968387e491a24010ebb9da28768a652..c317a558ff583c5a3f39683c2c6d781f77fa0ed2 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/activity/MessageCompose.java
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/activity/MessageCompose.java
@@ -110,6 +110,7 @@ import com.fsck.k9.search.LocalSearch;
 import com.fsck.k9.ui.R;
 import com.fsck.k9.ui.base.K9Activity;
 import com.fsck.k9.ui.base.ThemeManager;
+import com.fsck.k9.ui.compose.WrapUriTextWatcher;
 import com.fsck.k9.ui.compose.QuotedMessageMvpView;
 import com.fsck.k9.ui.compose.QuotedMessagePresenter;
 import com.fsck.k9.ui.helper.SizeFormatter;
@@ -362,10 +363,12 @@ public class MessageCompose extends K9Activity implements OnClickListener,
         replyToView.addTextChangedListener(draftNeedsChangingTextWatcher);
         recipientMvpView.addTextChangedListener(draftNeedsChangingTextWatcher);
         quotedMessageMvpView.addTextChangedListener(draftNeedsChangingTextWatcher);
+        quotedMessageMvpView.addTextChangedListener(new WrapUriTextWatcher());
 
         subjectView.addTextChangedListener(draftNeedsChangingTextWatcher);
 
         messageContentView.addTextChangedListener(draftNeedsChangingTextWatcher);
+        messageContentView.addTextChangedListener(new WrapUriTextWatcher());
 
         /*
          * We set this to invisible by default. Other methods will turn it back on if it's
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/activity/MessageList.kt b/app/ui/legacy/src/main/java/com/fsck/k9/activity/MessageList.kt
index a4a112975425eaff46be35ef1dcff81305eef106..4452e51fa6a7fca7c0096df0b770ea2865366b55 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/activity/MessageList.kt
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/activity/MessageList.kt
@@ -49,11 +49,14 @@ import androidx.lifecycle.Observer
 import androidx.lifecycle.lifecycleScope
 import app.k9mail.core.android.common.contact.CachingRepository
 import app.k9mail.core.android.common.contact.ContactRepository
+import app.k9mail.core.featureflag.FeatureFlagKey
+import app.k9mail.core.featureflag.FeatureFlagProvider
+import app.k9mail.feature.launcher.FeatureLauncherActivity
 import com.fsck.k9.Account
 import com.fsck.k9.K9
 import com.fsck.k9.K9.SplitViewMode
 import com.fsck.k9.Preferences
-import com.fsck.k9.account.AccountCreator
+import com.fsck.k9.account.AccountCreatorHelper
 import com.fsck.k9.account.BackgroundAccountRemover
 import com.fsck.k9.activity.compose.MessageActions
 import com.fsck.k9.activity.setup.accountmanager.EeloAccountCreator
@@ -119,8 +122,9 @@ open class MessageList :
     private val generalSettingsManager: GeneralSettingsManager by inject()
     private val messagingController: MessagingController by inject()
     private val jobManager: K9JobManager by inject()
-    private val accountCreator: AccountCreator by inject()
+    private val accountCreatorHelper: AccountCreatorHelper by inject()
     private val contactRepository: ContactRepository by inject()
+    private val featureFlagProvider: FeatureFlagProvider by inject()
 
     private val permissionUiHelper: PermissionUiHelper = K9PermissionUiHelper(this)
 
@@ -185,9 +189,14 @@ open class MessageList :
         if (!hasAccountSetup) {
             generalSettingsManager.setReloadAccountChipsColors(false)
 
-
-            val intent = Intent(this, OnboardingActivity::class.java)
-            startActivity(intent)
+            featureFlagProvider.provide(FeatureFlagKey("new_onboarding")).onEnabled {
+                FeatureLauncherActivity.launchOnboarding(this)
+            }.onDisabled {
+                OnboardingActivity.launch(this)
+            }.onUnavailable {
+                Timber.d("Feature flag 'new_onboarding' is unavailable, falling back to old onboarding")
+                OnboardingActivity.launch(this)
+            }
             finish()
             return
         }
@@ -261,7 +270,7 @@ open class MessageList :
 
     private fun updateAccountColors(accounts: List<Account>) {
         accounts.forEach {
-            it.chipColor = accountCreator.pickColor()
+            it.chipColor = accountCreatorHelper.pickColor()
             preferences.saveAccount(it)
         }
     }
@@ -1137,6 +1146,7 @@ open class MessageList :
         showMessageViewPlaceHolder()
 
         val tmpSearch = LocalSearch().apply {
+            setId(search?.id)
             addAccountUuid(account.uuid)
             and(SearchField.THREAD_ID, threadRootId.toString(), SearchSpecification.Attribute.EQUALS)
         }
@@ -1473,7 +1483,7 @@ open class MessageList :
         private const val ACTION_SHORTCUT = "shortcut"
         private const val EXTRA_SPECIAL_FOLDER = "special_folder"
 
-        private const val EXTRA_ACCOUNT = "account_uuid"
+        const val EXTRA_ACCOUNT = "account_uuid"
         private const val EXTRA_MESSAGE_REFERENCE = "message_reference"
         private const val EXTRA_MESSAGE_VIEW_ONLY = "message_view_only"
 
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/activity/compose/RecipientLoader.java b/app/ui/legacy/src/main/java/com/fsck/k9/activity/compose/RecipientLoader.java
index e5fd41de2a374c429b69bd27516e6c9ca920c1b6..e3931375fe236f98b5b0fd444018362a21e085a3 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/activity/compose/RecipientLoader.java
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/activity/compose/RecipientLoader.java
@@ -72,11 +72,9 @@ public class RecipientLoader extends AsyncTaskLoader<List<Recipient>> {
 
     private static final String[] PROJECTION_NICKNAME = {
             ContactsContract.Data.CONTACT_ID,
-            ContactsContract.CommonDataKinds.Nickname.NAME
     };
 
     private static final int INDEX_CONTACT_ID_FOR_NICKNAME = 0;
-    private static final int INDEX_NICKNAME = 1;
 
     private static final String[] PROJECTION_CRYPTO_ADDRESSES = {
             "address",
@@ -377,8 +375,7 @@ public class RecipientLoader extends AsyncTaskLoader<List<Recipient>> {
                 Cursor cursor = contentResolver
                         .query(queryUri, PROJECTION, selection, new String[] { id }, SORT_ORDER);
 
-                String contactNickname = nicknameCursor.getString(INDEX_NICKNAME);
-                fillContactDataFromCursor(cursor, recipients, recipientMap, contactNickname, null);
+                fillContactDataFromCursor(cursor, recipients, recipientMap, null);
 
                 hasContact = true;
             }
@@ -403,7 +400,7 @@ public class RecipientLoader extends AsyncTaskLoader<List<Recipient>> {
             return recipients;
         }
 
-        fillContactDataFromCursor(cursor, recipients, new HashMap<>(), null, maxRecipients);
+        fillContactDataFromCursor(cursor, recipients, new HashMap<>(), maxRecipients);
 
         return recipients;
     }
@@ -437,15 +434,14 @@ public class RecipientLoader extends AsyncTaskLoader<List<Recipient>> {
 
     private void fillContactDataFromCursor(Cursor cursor, List<Recipient> recipients,
             Map<String, Recipient> recipientMap) {
-        fillContactDataFromCursor(cursor, recipients, recipientMap, null, null);
+        fillContactDataFromCursor(cursor, recipients, recipientMap, null);
     }
 
     private void fillContactDataFromCursor(Cursor cursor, List<Recipient> recipients,
-            Map<String, Recipient> recipientMap, @Nullable String prefilledName, @Nullable Integer maxRecipients) {
+            Map<String, Recipient> recipientMap, @Nullable Integer maxRecipients) {
 
         while (cursor.moveToNext() && (maxRecipients == null || recipients.size() < maxRecipients)) {
-            String name = prefilledName != null ? prefilledName : cursor.getString(INDEX_NAME);
-
+            String name = cursor.getString(INDEX_NAME);
             String email = cursor.getString(INDEX_EMAIL);
 
             // already exists? just skip then
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/activity/compose/RecipientMvpView.kt b/app/ui/legacy/src/main/java/com/fsck/k9/activity/compose/RecipientMvpView.kt
index 87be24e20d07a35f9a2f2bcf808a149d4dbc4b02..043470e167e29f36d18d77634e09264c3eaa8038 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/activity/compose/RecipientMvpView.kt
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/activity/compose/RecipientMvpView.kt
@@ -192,6 +192,30 @@ class RecipientMvpView(private val activity: MessageCompose) : View.OnFocusChang
         }
     }
 
+    fun silentlyAddRecipients(recipientType: RecipientType, vararg recipients: Recipient) {
+        removeAllTextListenersFromView(recipientType)
+        addRecipients(recipientType, *recipients)
+        addAllTextListenersToView(recipientType)
+    }
+
+    private fun removeAllTextListenersFromView(recipientType: RecipientType) {
+        when (recipientType) {
+            RecipientType.TO -> removeAllTextChangedListeners(toView)
+            RecipientType.CC -> removeAllTextChangedListeners(ccView)
+            RecipientType.BCC -> removeAllTextChangedListeners(bccView)
+            else -> throw AssertionError("Unsupported type: $recipientType")
+        }
+    }
+
+    private fun addAllTextListenersToView(recipientType: RecipientType) {
+        when (recipientType) {
+            RecipientType.TO -> addAllTextChangedListeners(toView)
+            RecipientType.CC -> addAllTextChangedListeners(ccView)
+            RecipientType.BCC -> addAllTextChangedListeners(bccView)
+            else -> throw AssertionError("Unsupported type: $recipientType")
+        }
+    }
+
     fun silentlyAddBccAddresses(vararg recipients: Recipient) {
         removeAllTextChangedListeners(bccView)
 
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/activity/compose/RecipientPresenter.kt b/app/ui/legacy/src/main/java/com/fsck/k9/activity/compose/RecipientPresenter.kt
index b95a4ab1bbd0641295265bfe85c78bbdf957fa88..06215a7acdab181eef98f3231f63daabe19f4f3e 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/activity/compose/RecipientPresenter.kt
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/activity/compose/RecipientPresenter.kt
@@ -98,6 +98,24 @@ class RecipientPresenter(
 
     private var openPgpKeySetupUtil : OpenPgpKeySetupUtil? = null
 
+    private val openPgpCallback = object : OpenPgpApiManagerCallback {
+        override fun onOpenPgpProviderStatusChanged() {
+            if (openPgpApiManager.openPgpProviderState == OpenPgpProviderState.UI_REQUIRED) {
+                recipientMvpView.showErrorOpenPgpUserInteractionRequired()
+            }
+            asyncUpdateCryptoStatus()
+        }
+
+        override fun onOpenPgpProviderError(error: OpenPgpProviderError) {
+            when (error) {
+                OpenPgpProviderError.ConnectionLost -> openPgpApiManager.refreshConnection()
+                OpenPgpProviderError.VersionIncompatible -> recipientMvpView.showErrorOpenPgpIncompatible()
+                OpenPgpProviderError.ConnectionFailed -> recipientMvpView.showErrorOpenPgpConnection()
+                else -> recipientMvpView.showErrorOpenPgpConnection()
+            }
+        }
+    }
+
     init {
         recipientMvpView.setPresenter(this)
         recipientMvpView.setLoaderManager(loaderManager)
@@ -485,7 +503,7 @@ class RecipientPresenter(
         object : RecipientLoader(context, account.openPgpProvider, *addresses) {
             override fun deliverResult(result: List<Recipient>?) {
                 val recipientArray = result!!.toTypedArray()
-                recipientMvpView.addRecipients(recipientType, *recipientArray)
+                recipientMvpView.silentlyAddRecipients(recipientType, *recipientArray)
 
                 stopLoading()
                 abandon()
@@ -813,25 +831,6 @@ class RecipientPresenter(
         }
     }
 
-    private val openPgpCallback = object : OpenPgpApiManagerCallback {
-        override fun onOpenPgpProviderStatusChanged() {
-            if (openPgpApiManager.openPgpProviderState == OpenPgpProviderState.UI_REQUIRED) {
-                recipientMvpView.showErrorOpenPgpUserInteractionRequired()
-            }
-
-            asyncUpdateCryptoStatus()
-        }
-
-        override fun onOpenPgpProviderError(error: OpenPgpProviderError) {
-            when (error) {
-                OpenPgpProviderError.ConnectionLost -> openPgpApiManager.refreshConnection()
-                OpenPgpProviderError.VersionIncompatible -> recipientMvpView.showErrorOpenPgpIncompatible()
-                OpenPgpProviderError.ConnectionFailed -> recipientMvpView.showErrorOpenPgpConnection()
-                else -> recipientMvpView.showErrorOpenPgpConnection()
-            }
-        }
-    }
-
     private fun Array<String>.toAddressArray(): Array<Address> {
         return flatMap { addressString ->
             Address.parseUnencoded(addressString).toList()
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/AccountSetupAccountType.kt b/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/AccountSetupAccountType.kt
index bad872a2ce907bd9266fd8db4543b84eeca46f0f..d864fc6dda14e3f79eaf001b7dfcbfebed0f8f4d 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/AccountSetupAccountType.kt
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/AccountSetupAccountType.kt
@@ -4,14 +4,14 @@ import android.content.Context
 import android.content.Intent
 import android.os.Bundle
 import android.view.View
+import app.k9mail.core.common.mail.Protocols
+import app.k9mail.feature.account.oauth.domain.DomainContract.UseCase.SuggestServerName
 import com.fsck.k9.Account
 import com.fsck.k9.Preferences
 import com.fsck.k9.helper.EmailHelper.getDomainFromEmailAddress
 import com.fsck.k9.mail.ConnectionSecurity
 import com.fsck.k9.mail.ServerSettings
 import com.fsck.k9.mailstore.SpecialLocalFoldersCreator
-import com.fsck.k9.preferences.Protocols
-import com.fsck.k9.setup.ServerNameSuggester
 import com.fsck.k9.ui.R
 import com.fsck.k9.ui.base.K9Activity
 import org.koin.android.ext.android.inject
@@ -23,7 +23,7 @@ import org.koin.android.ext.android.inject
  */
 class AccountSetupAccountType : K9Activity() {
     private val preferences: Preferences by inject()
-    private val serverNameSuggester: ServerNameSuggester by inject()
+    private val serverNameSuggester: SuggestServerName by inject()
     private val localFoldersCreator: SpecialLocalFoldersCreator by inject()
 
     private lateinit var account: Account
@@ -71,7 +71,7 @@ class AccountSetupAccountType : K9Activity() {
     }
 
     private fun initializeIncomingServerSettings(serverType: String, domainPart: String) {
-        val suggestedStoreServerName = serverNameSuggester.suggestServerName(serverType, domainPart)
+        val suggestedStoreServerName = serverNameSuggester.suggest(serverType, domainPart)
         val storeServer = ServerSettings(
             serverType,
             suggestedStoreServerName,
@@ -86,7 +86,7 @@ class AccountSetupAccountType : K9Activity() {
     }
 
     private fun initializeOutgoingServerSettings(domainPart: String) {
-        val suggestedTransportServerName = serverNameSuggester.suggestServerName(Protocols.SMTP, domainPart)
+        val suggestedTransportServerName = serverNameSuggester.suggest(Protocols.SMTP, domainPart)
         val transportServer = ServerSettings(
             Protocols.SMTP,
             suggestedTransportServerName,
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/AccountSetupBasics.kt b/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/AccountSetupBasics.kt
index 9bc6fd23278e7a59bf8ec8a63d6eb6e0fc94ed9a..68d40beee6c689f102bfb464bd15fe4bdd287fc6 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/AccountSetupBasics.kt
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/AccountSetupBasics.kt
@@ -18,7 +18,7 @@ import com.fsck.k9.Account
 import com.fsck.k9.Core
 import com.fsck.k9.EmailAddressValidator
 import com.fsck.k9.Preferences
-import com.fsck.k9.account.AccountCreator
+import com.fsck.k9.account.AccountCreatorHelper
 import com.fsck.k9.activity.MessageList
 import com.fsck.k9.activity.setup.AccountSetupCheckSettings.CheckDirection
 import com.fsck.k9.activity.setup.accountmanager.MailAutoConfigDiscovery
@@ -27,7 +27,6 @@ import com.fsck.k9.helper.Utility.requiredFieldValid
 import com.fsck.k9.mail.AuthType
 import com.fsck.k9.mail.ServerSettings
 import com.fsck.k9.mailstore.SpecialLocalFoldersCreator
-import com.fsck.k9.oauth.OAuthConfigurationProvider
 import com.fsck.k9.setup.AccountManagerConstants
 import com.fsck.k9.ui.ConnectionSettings
 import com.fsck.k9.ui.R
@@ -52,13 +51,11 @@ import org.koin.android.ext.android.inject
  */
 class AccountSetupBasics : K9Activity() {
     private val providersXmlDiscovery: ProvidersXmlDiscovery by inject()
-    private val accountCreator: AccountCreator by inject()
+    private val accountCreatorHelper: AccountCreatorHelper by inject()
     private val localFoldersCreator: SpecialLocalFoldersCreator by inject()
     private val preferences: Preferences by inject()
     private val emailValidator: EmailAddressValidator by inject()
 
-    private val oAuthConfigurationProvider: OAuthConfigurationProvider by inject()
-
     private lateinit var emailView: TextInputEditText
     private lateinit var passwordView: TextInputEditText
     private lateinit var passwordLayout: View
@@ -310,7 +307,7 @@ class AccountSetupBasics : K9Activity() {
         val outgoingServerSettings = connectionSettings.outgoing.newPassword(password)
         account.outgoingServerSettings = outgoingServerSettings
 
-        account.deletePolicy = accountCreator.getDefaultDeletePolicy(incomingServerSettings.type)
+        account.deletePolicy = accountCreatorHelper.getDefaultDeletePolicy(incomingServerSettings.type)
 
         localFoldersCreator.createSpecialLocalFolders(account)
 
@@ -356,7 +353,7 @@ class AccountSetupBasics : K9Activity() {
 
     private fun createAccount(): Account {
         return preferences.newAccount().apply {
-            chipColor = accountCreator.pickColor()
+            chipColor = accountCreatorHelper.pickColor()
         }
     }
 
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/AccountSetupIncoming.java b/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/AccountSetupIncoming.java
index 37ddc2bab7dc3645243387b74e9f3c1dee437066..3f789ea71f22a461e5a2a690b0ac2b333723f53e 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/AccountSetupIncoming.java
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/AccountSetupIncoming.java
@@ -1,4 +1,3 @@
-
 package com.fsck.k9.activity.setup;
 
 
@@ -26,11 +25,13 @@ import android.widget.Spinner;
 import android.widget.Toast;
 
 import androidx.annotation.NonNull;
+import app.k9mail.core.common.mail.Protocols;
+import app.k9mail.feature.account.oauth.domain.DomainContract.UseCase.SuggestServerName;
 import com.fsck.k9.Account;
 import com.fsck.k9.DI;
 import com.fsck.k9.LocalKeyStoreManager;
 import com.fsck.k9.Preferences;
-import com.fsck.k9.account.AccountCreator;
+import com.fsck.k9.account.AccountCreatorHelper;
 import com.fsck.k9.activity.setup.AccountSetupCheckSettings.CheckDirection;
 import com.fsck.k9.helper.EmailHelper;
 import com.fsck.k9.helper.Utility;
@@ -39,8 +40,6 @@ import com.fsck.k9.mail.ConnectionSecurity;
 import com.fsck.k9.mail.MailServerDirection;
 import com.fsck.k9.mail.ServerSettings;
 import com.fsck.k9.mail.store.imap.ImapStoreSettings;
-import com.fsck.k9.preferences.Protocols;
-import com.fsck.k9.setup.ServerNameSuggester;
 import com.fsck.k9.ui.R;
 import com.fsck.k9.ui.base.K9Activity;
 import com.fsck.k9.ui.base.extensions.TextInputLayoutHelper;
@@ -59,8 +58,8 @@ public class AccountSetupIncoming extends K9Activity implements OnClickListener
     private static final String STATE_SECURITY_TYPE_POSITION = "stateSecurityTypePosition";
     private static final String STATE_AUTH_TYPE_POSITION = "authTypePosition";
 
-    private final AccountCreator accountCreator = DI.get(AccountCreator.class);
-    private final ServerNameSuggester serverNameSuggester = DI.get(ServerNameSuggester.class);
+    private final AccountCreatorHelper accountCreatorHelper = DI.get(AccountCreatorHelper.class);
+    private final SuggestServerName serverNameSuggester = DI.get(SuggestServerName.class);
 
     private String mStoreType;
     private TextInputEditText mUsernameView;
@@ -82,7 +81,6 @@ public class AccountSetupIncoming extends K9Activity implements OnClickListener
     private boolean mMakeDefault;
     private CheckBox useCompressionCheckBox;
     private CheckBox isSendClientIdEnabledCheckBox;
-    private CheckBox mSubscribedFoldersOnly;
     private AuthTypeAdapter mAuthTypeAdapter;
     private ConnectionSecurity[] mConnectionSecurityChoices = ConnectionSecurity.values();
     private boolean editSettings;
@@ -128,7 +126,6 @@ public class AccountSetupIncoming extends K9Activity implements OnClickListener
         mNextButton = findViewById(R.id.next);
         useCompressionCheckBox = findViewById(R.id.use_compression);
         isSendClientIdEnabledCheckBox = findViewById(R.id.is_send_client_id_enabled);
-        mSubscribedFoldersOnly = findViewById(R.id.subscribed_folders_only);
         mAllowClientCertificateView = findViewById(R.id.account_allow_client_certificate);
 
         TextInputLayout serverLayoutView = findViewById(R.id.account_server_layout);
@@ -204,7 +201,6 @@ public class AccountSetupIncoming extends K9Activity implements OnClickListener
                 findViewById(R.id.imap_path_prefix_section).setVisibility(View.GONE);
                 useCompressionCheckBox.setVisibility(View.GONE);
                 isSendClientIdEnabledCheckBox.setVisibility(View.GONE);
-                mSubscribedFoldersOnly.setVisibility(View.GONE);
             } else if (settings.type.equals(Protocols.IMAP)) {
                 serverLayoutView.setHint(getString(R.string.account_setup_incoming_imap_server_label));
 
@@ -215,27 +211,23 @@ public class AccountSetupIncoming extends K9Activity implements OnClickListener
                 if (pathPrefix != null) {
                     mImapPathPrefixView.setText(pathPrefix);
                 }
-
-                if (!editSettings) {
-                    findViewById(R.id.imap_folder_setup_section).setVisibility(View.GONE);
-                }
             } else {
                 throw new Exception("Unknown account type: " + settings.type);
             }
 
             if (!editSettings) {
-                mAccount.setDeletePolicy(accountCreator.getDefaultDeletePolicy(settings.type));
+                mAccount.setDeletePolicy(accountCreatorHelper.getDefaultDeletePolicy(settings.type));
             }
 
             // Note that mConnectionSecurityChoices is configured above based on server type
             ConnectionSecurityAdapter securityTypesAdapter =
-                    ConnectionSecurityAdapter.get(this, mConnectionSecurityChoices);
+                ConnectionSecurityAdapter.get(this, mConnectionSecurityChoices);
             mSecurityTypeView.setAdapter(securityTypesAdapter);
 
             // Select currently configured security type
             if (savedInstanceState == null) {
                 mCurrentSecurityTypeViewPosition =
-                        securityTypesAdapter.getConnectionSecurityPosition(settings.connectionSecurity);
+                    securityTypesAdapter.getConnectionSecurityPosition(settings.connectionSecurity);
             } else {
 
                 /*
@@ -266,8 +258,6 @@ public class AccountSetupIncoming extends K9Activity implements OnClickListener
                 updatePortFromSecurityType();
             }
             mCurrentPortViewSetting = mPortView.getText().toString();
-
-            mSubscribedFoldersOnly.setChecked(mAccount.isSubscribedFoldersOnly());
         } catch (Exception e) {
             failure(e);
         }
@@ -287,7 +277,7 @@ public class AccountSetupIncoming extends K9Activity implements OnClickListener
         mSecurityTypeView.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
             @Override
             public void onItemSelected(AdapterView<?> parent, View view, int position,
-                    long id) {
+                long id) {
 
                 /*
                  * We keep our own record of the spinner state so we
@@ -310,7 +300,7 @@ public class AccountSetupIncoming extends K9Activity implements OnClickListener
         mAuthTypeView.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
             @Override
             public void onItemSelected(AdapterView<?> parent, View view, int position,
-                    long id) {
+                long id) {
                 if (mCurrentAuthTypeViewPosition == position) {
                     return;
                 }
@@ -341,11 +331,11 @@ public class AccountSetupIncoming extends K9Activity implements OnClickListener
 
         if (editSettings) {
             TextInputLayoutHelper.configureAuthenticatedPasswordToggle(
-                    mPasswordLayoutView,
-                    this,
-                    getString(R.string.account_setup_basics_show_password_biometrics_title),
-                    getString(R.string.account_setup_basics_show_password_biometrics_subtitle),
-                    getString(R.string.account_setup_basics_show_password_need_lock)
+                mPasswordLayoutView,
+                this,
+                getString(R.string.account_setup_basics_show_password_biometrics_title),
+                getString(R.string.account_setup_basics_show_password_biometrics_subtitle),
+                getString(R.string.account_setup_basics_show_password_need_lock)
             );
         }
     }
@@ -393,7 +383,7 @@ public class AccountSetupIncoming extends K9Activity implements OnClickListener
     private void updateViewFromSecurity() {
         ConnectionSecurity security = getSelectedSecurity();
         boolean isUsingTLS = ((ConnectionSecurity.SSL_TLS_REQUIRED == security) ||
-                (ConnectionSecurity.STARTTLS_REQUIRED == security));
+            (ConnectionSecurity.STARTTLS_REQUIRED == security));
         boolean isUsingOAuth = getSelectedAuthType() == AuthType.XOAUTH2;
 
         if (isUsingTLS && !isUsingOAuth) {
@@ -404,8 +394,8 @@ public class AccountSetupIncoming extends K9Activity implements OnClickListener
     }
 
     /**
-     * This is invoked only when the user makes changes to a widget, not when widgets are changed programmatically.
-     * (The logic is simpler when you know that this is the last thing called after an input change.)
+     * This is invoked only when the user makes changes to a widget, not when widgets are changed programmatically. (The
+     * logic is simpler when you know that this is the last thing called after an input change.)
      */
     private void validateFields() {
         AuthType authType = getSelectedAuthType();
@@ -418,10 +408,10 @@ public class AccountSetupIncoming extends K9Activity implements OnClickListener
 
             // Notify user of an invalid combination of AuthType.EXTERNAL & ConnectionSecurity.NONE
             String toastText = getString(R.string.account_setup_incoming_invalid_setting_combo_notice,
-                    getString(R.string.account_setup_incoming_auth_type_label),
-                    AuthType.EXTERNAL.toString(),
-                    getString(R.string.account_setup_incoming_security_label),
-                    ConnectionSecurity.NONE.toString());
+                getString(R.string.account_setup_incoming_auth_type_label),
+                AuthType.EXTERNAL.toString(),
+                getString(R.string.account_setup_incoming_security_label),
+                ConnectionSecurity.NONE.toString());
             Toast.makeText(this, toastText, Toast.LENGTH_LONG).show();
 
             // Reset the views back to their previous settings without recursing through here again
@@ -458,21 +448,21 @@ public class AccountSetupIncoming extends K9Activity implements OnClickListener
         boolean hasValidUserName = Utility.requiredFieldValid(mUsernameView);
 
         boolean hasValidPasswordSettings = hasValidUserName
-                && !isAuthTypeExternal
-                && Utility.requiredFieldValid(mPasswordView);
+            && !isAuthTypeExternal
+            && Utility.requiredFieldValid(mPasswordView);
 
         boolean hasValidExternalAuthSettings = hasValidUserName
-                && isAuthTypeExternal
-                && hasConnectionSecurity
-                && hasValidCertificateAlias;
+            && isAuthTypeExternal
+            && hasConnectionSecurity
+            && hasValidCertificateAlias;
 
         boolean hasValidOAuthSettings = hasValidUserName
-                && hasConnectionSecurity
-                && authType == AuthType.XOAUTH2;
+            && hasConnectionSecurity
+            && authType == AuthType.XOAUTH2;
 
         mNextButton.setEnabled(Utility.domainFieldValid(mServerView)
-                && Utility.requiredFieldValid(mPortView)
-                && (hasValidPasswordSettings || hasValidExternalAuthSettings || hasValidOAuthSettings));
+            && Utility.requiredFieldValid(mPortView)
+            && (hasValidPasswordSettings || hasValidExternalAuthSettings || hasValidOAuthSettings));
         Utility.setCompoundDrawablesAlpha(mNextButton, mNextButton.isEnabled() ? 255 : 128);
     }
 
@@ -484,7 +474,7 @@ public class AccountSetupIncoming extends K9Activity implements OnClickListener
         // Remove listener so as not to trigger validateFields() which is called
         // elsewhere as a result of user interaction.
         mPortView.removeTextChangedListener(validationTextWatcher);
-        mPortView.setText(String.valueOf(accountCreator.getDefaultPort(securityType, mStoreType)));
+        mPortView.setText(String.valueOf(accountCreatorHelper.getDefaultPort(securityType, mStoreType)));
         mPortView.addTextChangedListener(validationTextWatcher);
     }
 
@@ -514,7 +504,7 @@ public class AccountSetupIncoming extends K9Activity implements OnClickListener
                 String clientCertificateAlias = null;
                 AuthType authType = getSelectedAuthType();
                 if ((ConnectionSecurity.SSL_TLS_REQUIRED == getSelectedSecurity()) ||
-                        (ConnectionSecurity.STARTTLS_REQUIRED == getSelectedSecurity())) {
+                    (ConnectionSecurity.STARTTLS_REQUIRED == getSelectedSecurity())) {
                     clientCertificateAlias = mClientCertificateSpinner.getAlias();
                 }
                 if (AuthType.EXTERNAL != authType) {
@@ -522,10 +512,10 @@ public class AccountSetupIncoming extends K9Activity implements OnClickListener
                 }
 
                 String domain = EmailHelper.getDomainFromEmailAddress(mAccount.getEmail());
-                String host = serverNameSuggester.suggestServerName(Protocols.SMTP, domain);
+                String host = serverNameSuggester.suggest(Protocols.SMTP, domain);
                 ServerSettings transportServer = new ServerSettings(Protocols.SMTP, host,
-                        -1, ConnectionSecurity.SSL_TLS_REQUIRED, authType, username, password,
-                        clientCertificateAlias);
+                    -1, ConnectionSecurity.SSL_TLS_REQUIRED, authType, username, password,
+                    clientCertificateAlias);
                 mAccount.setOutgoingServerSettings(transportServer);
 
                 AccountSetupOutgoing.actionOutgoingSettings(this, mAccount);
@@ -554,7 +544,7 @@ public class AccountSetupIncoming extends K9Activity implements OnClickListener
             AuthType authType = getSelectedAuthType();
 
             if ((ConnectionSecurity.SSL_TLS_REQUIRED == connectionSecurity) ||
-                    (ConnectionSecurity.STARTTLS_REQUIRED == connectionSecurity)) {
+                (ConnectionSecurity.STARTTLS_REQUIRED == connectionSecurity)) {
                 clientCertificateAlias = mClientCertificateSpinner.getAlias();
             }
             if (authType != AuthType.EXTERNAL) {
@@ -572,13 +562,12 @@ public class AccountSetupIncoming extends K9Activity implements OnClickListener
 
             DI.get(LocalKeyStoreManager.class).deleteCertificate(mAccount, host, port, MailServerDirection.INCOMING);
             ServerSettings settings = new ServerSettings(mStoreType, host, port,
-                    connectionSecurity, authType, username, password, clientCertificateAlias, extra);
+                connectionSecurity, authType, username, password, clientCertificateAlias, extra);
 
             mAccount.setIncomingServerSettings(settings);
 
             mAccount.setUseCompression(useCompressionCheckBox.isChecked());
             mAccount.setSendClientIdEnabled(isSendClientIdEnabledCheckBox.isChecked());
-            mAccount.setSubscribedFoldersOnly(mSubscribedFoldersOnly.isChecked());
 
             AccountSetupCheckSettings.actionCheckSettings(this, mAccount, CheckDirection.INCOMING);
         } catch (Exception e) {
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/AccountSetupNames.java b/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/AccountSetupNames.java
index 603232baeebd9fa366361542dc74f3786239e30b..3c0d672790c038713e7769849da9f7da01762415 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/AccountSetupNames.java
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/AccountSetupNames.java
@@ -21,6 +21,7 @@ import com.fsck.k9.activity.MessageList;
 import com.fsck.k9.ui.R;
 import com.fsck.k9.helper.Utility;
 
+@Deprecated(since = "New account setup flow")
 public class AccountSetupNames extends K9Activity implements OnClickListener {
     private static final String EXTRA_ACCOUNT = "account";
 
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/AccountSetupOptions.java b/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/AccountSetupOptions.java
index eb785d3f5c52d2fbec323f518b7778f9f82cdb21..43fd54f798b2c49e76b3535e567c3d97d4b5a6dd 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/AccountSetupOptions.java
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/AccountSetupOptions.java
@@ -18,6 +18,7 @@ import com.fsck.k9.ui.R;
 import com.fsck.k9.ui.base.K9Activity;
 
 
+@Deprecated(since = "New account setup flow")
 public class AccountSetupOptions extends K9Activity implements OnClickListener {
     private static final String EXTRA_ACCOUNT = "account";
 
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/AccountSetupOutgoing.java b/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/AccountSetupOutgoing.java
index 2c70eb5515c08c98e94f2fbe078733db0cc324b8..d2b6d3a354921de779fd36e959122e117f81e823 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/AccountSetupOutgoing.java
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/AccountSetupOutgoing.java
@@ -28,9 +28,9 @@ import com.fsck.k9.Account;
 import com.fsck.k9.DI;
 import com.fsck.k9.LocalKeyStoreManager;
 import com.fsck.k9.Preferences;
-import com.fsck.k9.preferences.Protocols;
+import app.k9mail.core.common.mail.Protocols;
 import com.fsck.k9.ui.R;
-import com.fsck.k9.account.AccountCreator;
+import com.fsck.k9.account.AccountCreatorHelper;
 import com.fsck.k9.ui.base.K9Activity;
 import com.fsck.k9.activity.setup.AccountSetupCheckSettings.CheckDirection;
 import com.fsck.k9.helper.Utility;
@@ -54,7 +54,7 @@ public class AccountSetupOutgoing extends K9Activity implements OnClickListener,
     private static final String STATE_AUTH_TYPE_POSITION = "authTypePosition";
 
 
-    private final AccountCreator accountCreator = DI.get(AccountCreator.class);
+    private final AccountCreatorHelper accountCreatorHelper = DI.get(AccountCreatorHelper.class);
 
     private TextInputEditText mUsernameView;
     private TextInputEditText mPasswordView;
@@ -475,7 +475,7 @@ public class AccountSetupOutgoing extends K9Activity implements OnClickListener,
         // Remove listener so as not to trigger validateFields() which is called
         // elsewhere as a result of user interaction.
         mPortView.removeTextChangedListener(validationTextWatcher);
-        mPortView.setText(String.valueOf(accountCreator.getDefaultPort(securityType, Protocols.SMTP)));
+        mPortView.setText(String.valueOf(accountCreatorHelper.getDefaultPort(securityType, Protocols.SMTP)));
         mPortView.addTextChangedListener(validationTextWatcher);
     }
 
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/AuthViewModel.kt b/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/AuthViewModel.kt
index 38fd67ad7c2bb9e8ac1199a7c9291221eaa83b2c..d4278c660b32daa553ebb7d638b354239e897d44 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/AuthViewModel.kt
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/AuthViewModel.kt
@@ -8,15 +8,14 @@ import android.content.Intent
 import androidx.activity.result.ActivityResultLauncher
 import androidx.activity.result.ActivityResultRegistry
 import androidx.activity.result.contract.ActivityResultContract
-import androidx.core.net.toUri
 import androidx.lifecycle.AndroidViewModel
 import androidx.lifecycle.DefaultLifecycleObserver
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleOwner
 import androidx.lifecycle.viewModelScope
+import app.k9mail.feature.account.oauth.domain.DomainContract.UseCase.GetOAuthRequestIntent
+import app.k9mail.feature.account.oauth.domain.entity.AuthorizationIntentResult
 import com.fsck.k9.Account
-import com.fsck.k9.oauth.OAuthConfiguration
-import com.fsck.k9.oauth.OAuthConfigurationProvider
 import com.fsck.k9.preferences.AccountManager
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -27,11 +26,8 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import net.openid.appauth.AuthState
 import net.openid.appauth.AuthorizationException
-import net.openid.appauth.AuthorizationRequest
 import net.openid.appauth.AuthorizationResponse
 import net.openid.appauth.AuthorizationService
-import net.openid.appauth.AuthorizationServiceConfiguration
-import net.openid.appauth.ResponseTypeValues
 import timber.log.Timber
 
 private const val KEY_AUTHORIZATION = "app.k9mail_auth"
@@ -39,7 +35,7 @@ private const val KEY_AUTHORIZATION = "app.k9mail_auth"
 class AuthViewModel(
     application: Application,
     private val accountManager: AccountManager,
-    private val oAuthConfigurationProvider: OAuthConfigurationProvider,
+    private val getOAuthRequestIntent: GetOAuthRequestIntent,
 ) : AndroidViewModel(application) {
     private var authService: AuthorizationService? = null
     private val authState = AuthState()
@@ -72,7 +68,7 @@ class AuthViewModel(
     }
 
     fun isUsingGoogle(account: Account): Boolean {
-        return oAuthConfigurationProvider.isGoogle(account.incomingServerSettings.host!!)
+        return GoogleOAuthHelper.isGoogle(account.incomingServerSettings.host!!)
     }
 
     private fun getOrCreateAuthState(account: Account): AuthState {
@@ -88,54 +84,26 @@ class AuthViewModel(
         val account = checkNotNull(account)
 
         viewModelScope.launch {
-            val config = findOAuthConfiguration(account)
-            if (config == null) {
-                _uiState.update { AuthFlowState.NotSupported }
-                return@launch
-            }
-
             try {
-                startLogin(account, config)
+                startLogin(account)
             } catch (e: ActivityNotFoundException) {
                 _uiState.update { AuthFlowState.BrowserNotFound }
             }
         }
     }
 
-    private suspend fun startLogin(account: Account, config: OAuthConfiguration) {
-        val authRequestIntent = withContext(Dispatchers.IO) {
-            createAuthorizationRequestIntent(account.email, config)
+    private suspend fun startLogin(account: Account) {
+        val authRequestIntentResult = withContext(Dispatchers.IO) {
+            getOAuthRequestIntent.execute(account.incomingServerSettings.host!!, account.email)
         }
 
-        resultObserver.login(authRequestIntent)
-    }
-
-    private fun createAuthorizationRequestIntent(email: String, config: OAuthConfiguration): Intent {
-        val serviceConfig = AuthorizationServiceConfiguration(
-            config.authorizationEndpoint.toUri(),
-            config.tokenEndpoint.toUri(),
-        )
-
-        val authRequestBuilder = AuthorizationRequest.Builder(
-            serviceConfig,
-            config.clientId,
-            ResponseTypeValues.CODE,
-            config.redirectUri.toUri(),
-        )
-
-        val scopeString = config.scopes.joinToString(separator = " ")
-        val authRequest = authRequestBuilder
-            .setScope(scopeString)
-            .setLoginHint(email)
-            .build()
-
-        val authService = getAuthService()
-
-        return authService.getAuthorizationRequestIntent(authRequest)
-    }
+        when (authRequestIntentResult) {
+            AuthorizationIntentResult.NotSupported -> {
+                _uiState.update { AuthFlowState.NotSupported }
+            }
 
-    private fun findOAuthConfiguration(account: Account): OAuthConfiguration? {
-        return oAuthConfigurationProvider.getConfiguration(account.incomingServerSettings.host!!)
+            is AuthorizationIntentResult.Success -> resultObserver.login(authRequestIntentResult.intent)
+        }
     }
 
     private fun onLoginResult(authorizationResult: AuthorizationResult?) {
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/GoogleOAuthHelper.kt b/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/GoogleOAuthHelper.kt
new file mode 100644
index 0000000000000000000000000000000000000000..6db7daf88f54cafd337e823688cf3818deb91139
--- /dev/null
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/GoogleOAuthHelper.kt
@@ -0,0 +1,9 @@
+package com.fsck.k9.activity.setup
+
+@Deprecated("Could be removed with the legacy account setup UI")
+object GoogleOAuthHelper {
+    fun isGoogle(hostname: String): Boolean {
+        return hostname.lowercase().endsWith(".gmail.com") ||
+            hostname.lowercase().endsWith(".googlemail.com")
+    }
+}
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/accountmanager/EeloAccountCreator.java b/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/accountmanager/EeloAccountCreator.java
index 6eba1ec75b20395841b42f2b2e615c0d6b58b419..185ee1e587b3ae71ea734cdc438941a1990ceb5b 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/accountmanager/EeloAccountCreator.java
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/activity/setup/accountmanager/EeloAccountCreator.java
@@ -31,19 +31,19 @@ import androidx.annotation.WorkerThread;
 import app.k9mail.autodiscovery.api.DiscoveredServerSettings;
 import app.k9mail.autodiscovery.api.DiscoveryResults;
 import app.k9mail.autodiscovery.providersxml.ProvidersXmlDiscovery;
+import app.k9mail.core.common.mail.Protocols;
 import com.fsck.k9.Account;
 import com.fsck.k9.Account.DeletePolicy;
 import com.fsck.k9.Core;
 import com.fsck.k9.DI;
 import com.fsck.k9.Preferences;
-import com.fsck.k9.account.AccountCreator;
+import com.fsck.k9.account.AccountCreatorHelper;
 import com.fsck.k9.account.BackgroundAccountRemover;
 import com.fsck.k9.job.K9JobManager;
 import com.fsck.k9.mail.AuthType;
 import com.fsck.k9.mail.ConnectionSecurity;
 import com.fsck.k9.mail.ServerSettings;
 import com.fsck.k9.mailstore.SpecialLocalFoldersCreator;
-import com.fsck.k9.preferences.Protocols;
 import com.fsck.k9.setup.AccountManagerConstants;
 import com.fsck.k9.ui.ConnectionSettings;
 import timber.log.Timber;
@@ -51,13 +51,14 @@ import timber.log.Timber;
 
 public class EeloAccountCreator {
     private static final ProvidersXmlDiscovery providersXmlDiscovery = DI.get(ProvidersXmlDiscovery.class);
-    private static final AccountCreator accountCreator = DI.get(AccountCreator.class);
+    private static final AccountCreatorHelper accountCreatorHelper = DI.get(AccountCreatorHelper.class);
     private static final SpecialLocalFoldersCreator localFoldersCreator = DI.get(SpecialLocalFoldersCreator.class);
 
     @RequiresApi(api = VERSION_CODES.N)
     @WorkerThread
     public static void loadAccountsFromAccountManager(@NonNull Context context, @NonNull Preferences preferences,
-            @NonNull BackgroundAccountRemover accountRemover, @NonNull K9JobManager jobManager, @Nullable OnAccountLoadCompleteCallBack callBack) {
+        @NonNull BackgroundAccountRemover accountRemover, @NonNull K9JobManager jobManager,
+        @Nullable OnAccountLoadCompleteCallBack callBack) {
         try {
             AccountManager accountManager = AccountManager.get(context);
 
@@ -66,7 +67,8 @@ public class EeloAccountCreator {
 
             loadEeloAccounts(context, accounts, accountManager, jobManager);
 
-            AccountManagerConstants.INSTANCE.getOPENID_ACCOUNT_TYPES().forEach(accountType -> loadOpenIdAccounts(context, accountType, accounts, accountManager, jobManager));
+            AccountManagerConstants.INSTANCE.getOPENID_ACCOUNT_TYPES()
+                .forEach(accountType -> loadOpenIdAccounts(context, accountType, accounts, accountManager, jobManager));
         } catch (SecurityException e) {
             Timber.e(e, "Failed to load accounts from accountManager because of security violation");
         }
@@ -90,13 +92,14 @@ public class EeloAccountCreator {
     }
 
     @RequiresApi(api = VERSION_CODES.N)
-    private static void loadOpenIdAccounts(@NonNull Context context, @NonNull String accountType, List<Account> accounts,
-            @NonNull AccountManager accountManager, @NonNull K9JobManager jobManager) {
+    private static void loadOpenIdAccounts(@NonNull Context context, @NonNull String accountType,
+        List<Account> accounts,
+        @NonNull AccountManager accountManager, @NonNull K9JobManager jobManager) {
         android.accounts.Account[] openIdAccounts =
-                accountManager.getAccountsByType(accountType);
+            accountManager.getAccountsByType(accountType);
         for (android.accounts.Account openIdAccount : openIdAccounts) {
             String emailId =
-                    accountManager.getUserData(openIdAccount, AccountManagerConstants.ACCOUNT_EMAIL_ADDRESS_KEY);
+                accountManager.getUserData(openIdAccount, AccountManagerConstants.ACCOUNT_EMAIL_ADDRESS_KEY);
             if (isInvalidEmail(emailId)) {
                 continue;
             }
@@ -110,9 +113,9 @@ public class EeloAccountCreator {
             }
 
             var existenceAccount = accounts.stream()
-                    .filter(account -> emailId.equalsIgnoreCase(account.getEmail()))
-                    .peek(account -> updateAccountNameIfMissing(context, emailId, account))
-                    .findAny();
+                .filter(account -> emailId.equalsIgnoreCase(account.getEmail()))
+                .peek(account -> updateAccountNameIfMissing(context, emailId, account))
+                .findAny();
 
             if (!existenceAccount.isPresent()) {
                 String authState = accountManager.getUserData(openIdAccount, AccountManagerConstants.KEY_AUTH_STATE);
@@ -128,6 +131,7 @@ public class EeloAccountCreator {
         final String authState = accountManager.getUserData(account, AccountManagerConstants.KEY_AUTH_STATE);
         return authState != null && !authState.trim().isEmpty();
     }
+
     private static void updateAccountNameIfMissing(@NonNull Context context, String emailId, Account account) {
         if (account.getName() == null) { // we need to fix an old bug
             account.setName(emailId);
@@ -141,9 +145,9 @@ public class EeloAccountCreator {
 
     @RequiresApi(api = VERSION_CODES.N)
     private static void loadEeloAccounts(@NonNull Context context, List<Account> accounts,
-            @NonNull AccountManager accountManager, @NonNull K9JobManager jobManager) {
+        @NonNull AccountManager accountManager, @NonNull K9JobManager jobManager) {
         android.accounts.Account[] eeloAccounts =
-                accountManager.getAccountsByType(AccountManagerConstants.EELO_ACCOUNT_TYPE);
+            accountManager.getAccountsByType(AccountManagerConstants.EELO_ACCOUNT_TYPE);
         for (android.accounts.Account eeloAccount : eeloAccounts) {
             String emailId = accountManager.getUserData(eeloAccount, AccountManagerConstants.ACCOUNT_EMAIL_ADDRESS_KEY);
             if (isInvalidEmail(emailId)) {
@@ -159,8 +163,8 @@ public class EeloAccountCreator {
             }
 
             var existenceAccount = accounts.stream()
-                    .filter(account -> emailId.equalsIgnoreCase(account.getEmail()))
-                    .findAny();
+                .filter(account -> emailId.equalsIgnoreCase(account.getEmail()))
+                .findAny();
 
             if (!existenceAccount.isPresent()) {
                 String password = accountManager.getPassword(eeloAccount);
@@ -175,14 +179,15 @@ public class EeloAccountCreator {
     @RequiresApi(api = VERSION_CODES.N)
     private static void deleteIncompleteAccounts(List<Account> accounts, BackgroundAccountRemover accountRemover) {
         accounts.stream().filter(account -> !account.isFinishedSetup())
-                .forEach(account -> accountRemover.removeAccountAsync(account.getUuid()));
+            .forEach(account -> accountRemover.removeAccountAsync(account.getUuid()));
     }
 
-    private static void createAccount(Context context, String emailId, String password, @Nullable String authState, @NonNull String accountType) {
+    private static void createAccount(Context context, String emailId, String password, @Nullable String authState,
+        @NonNull String accountType) {
         Preferences preferences = Preferences.getPreferences();
 
         Account account = preferences.newAccount();
-        account.setChipColor(accountCreator.pickColor());
+        account.setChipColor(accountCreatorHelper.pickColor());
         account.setEmail(emailId);
         account.setName(emailId);
         account.setSenderName(emailId);
@@ -215,7 +220,7 @@ public class EeloAccountCreator {
 
         account.setOAuthState(authState);
 
-        DeletePolicy deletePolicy = accountCreator.getDefaultDeletePolicy(incomingSettings.type);
+        DeletePolicy deletePolicy = accountCreatorHelper.getDefaultDeletePolicy(incomingSettings.type);
         account.setDeletePolicy(deletePolicy);
 
         localFoldersCreator.createSpecialLocalFolders(account);
@@ -227,38 +232,39 @@ public class EeloAccountCreator {
 
     private static ConnectionSettings providersXmlDiscoveryDiscover(String email) {
         DiscoveryResults discoveryResults =
-                providersXmlDiscovery.discover(email);
+            providersXmlDiscovery.discover(email);
         if (discoveryResults == null ||
-                (discoveryResults.getIncoming().size() < 1 || discoveryResults.getOutgoing().size() < 1)) {
+            (discoveryResults.getIncoming().size() < 1 || discoveryResults.getOutgoing().size() < 1)) {
             return null;
         }
         DiscoveredServerSettings incoming = discoveryResults.getIncoming().get(0);
         DiscoveredServerSettings outgoing = discoveryResults.getOutgoing().get(0);
         return new ConnectionSettings(
-                new ServerSettings(
-                        incoming.getProtocol(),
-                        incoming.getHost(),
-                        incoming.getPort(),
-                        incoming.getSecurity(),
-                        incoming.getAuthType(),
-                        incoming.getUsername(),
-                        null,
-                        null
-                ),
-                new ServerSettings(
-                        outgoing.getProtocol(),
-                        outgoing.getHost(),
-                        outgoing.getPort(),
-                        outgoing.getSecurity(),
-                        outgoing.getAuthType(),
-                        outgoing.getUsername(),
-                        null,
-                        null
-                )
+            new ServerSettings(
+                incoming.getProtocol(),
+                incoming.getHost(),
+                incoming.getPort(),
+                incoming.getSecurity(),
+                incoming.getAuthType(),
+                incoming.getUsername(),
+                null,
+                null
+            ),
+            new ServerSettings(
+                outgoing.getProtocol(),
+                outgoing.getHost(),
+                outgoing.getPort(),
+                outgoing.getSecurity(),
+                outgoing.getAuthType(),
+                outgoing.getUsername(),
+                null,
+                null
+            )
         );
     }
 
-    private static ConnectionSettings providersDefaultOpenIdAccountDiscover(@NonNull String email, @NonNull String accountType) {
+    private static ConnectionSettings providersDefaultOpenIdAccountDiscover(@NonNull String email,
+        @NonNull String accountType) {
         String incomingHost = "mail.ecloud.global";
         String outgoingHost = incomingHost;
         int outgoingPort = 587;
@@ -268,35 +274,35 @@ public class EeloAccountCreator {
             incomingHost = "imap.gmail.com";
             outgoingHost = "smtp.gmail.com";
             outgoingPort = 465;
-            outgoingConnectionSecurity =  ConnectionSecurity.SSL_TLS_REQUIRED;
+            outgoingConnectionSecurity = ConnectionSecurity.SSL_TLS_REQUIRED;
         } else if (accountType.equals(AccountManagerConstants.YAHOO_ACCOUNT_TYPE)) {
             incomingHost = "imap.mail.yahoo.com";
             outgoingHost = "smtp.mail.yahoo.com";
             outgoingPort = 465;
-            outgoingConnectionSecurity =  ConnectionSecurity.SSL_TLS_REQUIRED;
+            outgoingConnectionSecurity = ConnectionSecurity.SSL_TLS_REQUIRED;
         }
 
         return new ConnectionSettings(
-                new ServerSettings(
-                        Protocols.IMAP,
-                        incomingHost,
-                        993,
-                        ConnectionSecurity.SSL_TLS_REQUIRED,
-                        AuthType.XOAUTH2,
-                        email,
-                        null,
-                        null
-                ),
-                new ServerSettings(
-                        Protocols.SMTP,
-                        outgoingHost,
-                        outgoingPort,
-                        outgoingConnectionSecurity,
-                        AuthType.XOAUTH2,
-                        email,
-                        null,
-                        null
-                )
+            new ServerSettings(
+                Protocols.IMAP,
+                incomingHost,
+                993,
+                ConnectionSecurity.SSL_TLS_REQUIRED,
+                AuthType.XOAUTH2,
+                email,
+                null,
+                null
+            ),
+            new ServerSettings(
+                Protocols.SMTP,
+                outgoingHost,
+                outgoingPort,
+                outgoingConnectionSecurity,
+                AuthType.XOAUTH2,
+                email,
+                null,
+                null
+            )
         );
     }
 
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/contacts/ContactPhotoLoader.kt b/app/ui/legacy/src/main/java/com/fsck/k9/contacts/ContactPhotoLoader.kt
index 29b88aeedb274a8c3eab9bb8d2e478eae5753e38..363d4890c2f1c763146d3c7c8ba1cb098b64aaf6 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/contacts/ContactPhotoLoader.kt
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/contacts/ContactPhotoLoader.kt
@@ -3,8 +3,9 @@ package com.fsck.k9.contacts
 import android.content.ContentResolver
 import android.graphics.Bitmap
 import android.graphics.BitmapFactory
+import android.net.Uri
 import app.k9mail.core.android.common.contact.ContactRepository
-import app.k9mail.core.common.mail.EmailAddress
+import app.k9mail.core.common.mail.toEmailAddressOrNull
 import timber.log.Timber
 
 internal class ContactPhotoLoader(
@@ -12,7 +13,7 @@ internal class ContactPhotoLoader(
     private val contactRepository: ContactRepository,
 ) {
     fun loadContactPhoto(emailAddress: String): Bitmap? {
-        val photoUri = contactRepository.getContactFor(EmailAddress(emailAddress))?.photoUri ?: return null
+        val photoUri = getPhotoUri(emailAddress) ?: return null
         return try {
             contentResolver.openInputStream(photoUri).use { inputStream ->
                 BitmapFactory.decodeStream(inputStream)
@@ -22,4 +23,10 @@ internal class ContactPhotoLoader(
             null
         }
     }
+
+    private fun getPhotoUri(email: String): Uri? {
+        return email.toEmailAddressOrNull()?.let { emailAddress ->
+            contactRepository.getContactFor(emailAddress)?.photoUri
+        }
+    }
 }
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/ui/K9Drawer.kt b/app/ui/legacy/src/main/java/com/fsck/k9/ui/K9Drawer.kt
index 6aebee45b10a9079ae61b71dafc9c8bc42d4f8c9..d12d876e2fc51dbbd16c55f0ab8ea7ebc13bca1a 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/ui/K9Drawer.kt
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/ui/K9Drawer.kt
@@ -235,6 +235,11 @@ class K9Drawer(private val parent: MessageList, savedInstanceState: Bundle?) : K
     private fun setAccounts(displayAccounts: List<DisplayAccount>) {
         val oldSelectedBackgroundColor = selectedBackgroundColor
 
+        val isOpenedAccountStillAvailable = displayAccounts.any { it.account.uuid == openedAccountUuid }
+        if (!isOpenedAccountStillAvailable) {
+            openedAccountUuid = displayAccounts.first().account.uuid
+        }
+
         var newActiveProfile: IProfile? = null
         val accountItems = displayAccounts.map { displayAccount ->
             val account = displayAccount.account
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/ui/compose/WrapUriTextWatcher.kt b/app/ui/legacy/src/main/java/com/fsck/k9/ui/compose/WrapUriTextWatcher.kt
new file mode 100644
index 0000000000000000000000000000000000000000..969dab1ad27a67738a3d94067a165c36ade18f6f
--- /dev/null
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/ui/compose/WrapUriTextWatcher.kt
@@ -0,0 +1,41 @@
+package com.fsck.k9.ui.compose
+
+import android.text.Editable
+import android.text.TextWatcher
+import com.fsck.k9.message.html.UriMatcher
+
+private const val NO_INDEX = -1
+private const val MINIMUM_URI_LENGTH = 2 // scheme name + colon
+
+/**
+ * Wraps inserted URIs in angle brackets.
+ */
+class WrapUriTextWatcher : TextWatcher {
+    private var insertedStartIndex = NO_INDEX
+    private var insertedEndIndex = NO_INDEX
+
+    override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) = Unit
+
+    override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {
+        if (s == null || count < MINIMUM_URI_LENGTH) {
+            insertedStartIndex = NO_INDEX
+        } else {
+            insertedStartIndex = start
+            insertedEndIndex = start + count
+        }
+    }
+
+    override fun afterTextChanged(s: Editable?) {
+        // Changing s below will lead to this TextWatcher being invoked again. Keep necessary state local.
+        val insertedStartIndex = insertedStartIndex
+        val insertedEndIndex = insertedEndIndex
+
+        if (s != null && insertedStartIndex != NO_INDEX) {
+            val insertedText = s.subSequence(insertedStartIndex, insertedEndIndex)
+            if (UriMatcher.isValidUri(insertedText)) {
+                s.insert(insertedEndIndex, ">")
+                s.insert(insertedStartIndex, "<")
+            }
+        }
+    }
+}
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/ui/messagedetails/AddToContactsLauncher.kt b/app/ui/legacy/src/main/java/com/fsck/k9/ui/messagedetails/AddToContactsLauncher.kt
index 399883c40c587fe0c0be8c0b4e9c7df2aefb6c7a..72a6b2fd547321160a86d21904ef1b6b313b20a4 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/ui/messagedetails/AddToContactsLauncher.kt
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/ui/messagedetails/AddToContactsLauncher.kt
@@ -6,8 +6,8 @@ import android.provider.ContactsContract
 
 internal class AddToContactsLauncher {
     fun launch(context: Context, name: String?, email: String) {
-        val intent = Intent(Intent.ACTION_INSERT).apply {
-            type = ContactsContract.Contacts.CONTENT_TYPE
+        val intent = Intent(Intent.ACTION_INSERT_OR_EDIT).apply {
+            type = ContactsContract.Contacts.CONTENT_ITEM_TYPE
 
             putExtra(ContactsContract.Intents.Insert.EMAIL, email)
 
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/ui/messagedetails/MessageDetailsViewModel.kt b/app/ui/legacy/src/main/java/com/fsck/k9/ui/messagedetails/MessageDetailsViewModel.kt
index 9b3b5faa4ff9ac2af603f71bf5b546d1c32c95cb..63b46ed532847148a7c2dd1e957ad13175dea76a 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/ui/messagedetails/MessageDetailsViewModel.kt
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/ui/messagedetails/MessageDetailsViewModel.kt
@@ -2,12 +2,13 @@ package com.fsck.k9.ui.messagedetails
 
 import android.app.PendingIntent
 import android.content.res.Resources
+import android.net.Uri
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import app.k9mail.core.android.common.contact.CachingRepository
 import app.k9mail.core.android.common.contact.ContactPermissionResolver
 import app.k9mail.core.android.common.contact.ContactRepository
-import app.k9mail.core.common.mail.EmailAddress
+import app.k9mail.core.common.mail.toEmailAddressOrNull
 import com.fsck.k9.Account
 import com.fsck.k9.controller.MessageReference
 import com.fsck.k9.helper.ClipboardManager
@@ -30,6 +31,7 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.receiveAsFlow
 import kotlinx.coroutines.launch
 
+@Suppress("TooManyFunctions")
 internal class MessageDetailsViewModel(
     private val resources: Resources,
     private val messageRepository: MessageRepository,
@@ -130,11 +132,17 @@ internal class MessageDetailsViewModel(
             Participant(
                 displayName = displayName,
                 emailAddress = emailAddress,
-                contactLookupUri = contactRepository.getContactFor(EmailAddress(emailAddress))?.uri,
+                contactLookupUri = getContactLookupUri(emailAddress),
             )
         }
     }
 
+    private fun getContactLookupUri(email: String): Uri? {
+        return email.toEmailAddressOrNull()?.let { emailAddress ->
+            contactRepository.getContactFor(emailAddress)?.uri
+        }
+    }
+
     private fun Folder.toFolderInfo(): FolderInfoUi {
         return FolderInfoUi(
             displayName = folderNameFormatter.displayName(this),
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/ui/messagelist/MessageListFragment.kt b/app/ui/legacy/src/main/java/com/fsck/k9/ui/messagelist/MessageListFragment.kt
index f3b4d01237d5dd4375e3729bc33a807962f1366a..5d543c2371bcd8ea3771823a4bbac90029e53402 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/ui/messagelist/MessageListFragment.kt
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/ui/messagelist/MessageListFragment.kt
@@ -169,7 +169,7 @@ class MessageListFragment :
         }
 
     val isShowAccountChip: Boolean
-        get() = !isSingleAccountMode
+        get() = isUnifiedInbox || !isSingleAccountMode
 
     override fun onAttach(context: Context) {
         super.onAttach(context)
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/ui/messageview/DisplayRecipientsExtractor.kt b/app/ui/legacy/src/main/java/com/fsck/k9/ui/messageview/DisplayRecipientsExtractor.kt
index 95a10e4925fbe7629b409f2f3fb5b1c61be4059f..d56e02eadbb5693f1399dfc1c98a21b0d298927c 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/ui/messageview/DisplayRecipientsExtractor.kt
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/ui/messageview/DisplayRecipientsExtractor.kt
@@ -1,7 +1,6 @@
 package com.fsck.k9.ui.messageview
 
 import com.fsck.k9.Account
-import com.fsck.k9.mail.Address
 import com.fsck.k9.mail.Message
 
 /**
@@ -21,13 +20,12 @@ internal class DisplayRecipientsExtractor(
 
         val numberOfRecipients = toRecipients.size + ccRecipients.size + bccRecipients.size
 
-        val identity = sequenceOf(toRecipients, ccRecipients, bccRecipients)
+        val identityAddress = sequenceOf(toRecipients, ccRecipients, bccRecipients)
             .flatMap { addressArray -> addressArray.asSequence() }
-            .mapNotNull { address -> account.findIdentity(address) }
+            .filter { address -> account.isAnIdentity(address) }
             .firstOrNull()
 
-        val identityEmail = identity?.email
-        val maxAdditionalRecipients = if (identity != null) {
+        val maxAdditionalRecipients = if (identityAddress != null) {
             maxNumberOfDisplayRecipients - 1
         } else {
             maxNumberOfDisplayRecipients
@@ -35,13 +33,12 @@ internal class DisplayRecipientsExtractor(
 
         val recipientNames = sequenceOf(toRecipients, ccRecipients, bccRecipients)
             .flatMap { addressArray -> addressArray.asSequence() }
-            .filter { address -> address.address != identityEmail }
+            .filter { address -> address !== identityAddress }
             .map { address -> recipientFormatter.getDisplayName(address, account) }
             .take(maxAdditionalRecipients)
             .toList()
 
-        return if (identity != null) {
-            val identityAddress = Address(identity.email)
+        return if (identityAddress != null) {
             val meName = recipientFormatter.getDisplayName(identityAddress, account)
             val recipients = listOf(meName) + recipientNames
 
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/ui/messageview/MessageTopView.kt b/app/ui/legacy/src/main/java/com/fsck/k9/ui/messageview/MessageTopView.kt
index 35352bfa29644887a993951935412f3f28d4ab75..c55613365a294f99785548c40378e1a2a30a4e5b 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/ui/messageview/MessageTopView.kt
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/ui/messageview/MessageTopView.kt
@@ -19,6 +19,7 @@ import android.widget.ProgressBar
 import android.widget.TextView
 import app.k9mail.core.android.common.contact.ContactRepository
 import app.k9mail.core.common.mail.EmailAddress
+import app.k9mail.core.common.mail.toEmailAddressOrNull
 import com.fsck.k9.Account
 import com.fsck.k9.Account.ShowPictures
 import com.fsck.k9.mail.Message
@@ -262,15 +263,15 @@ class MessageTopView(
             return false
         }
         val senderEmailAddress = getSenderEmailAddress(message) ?: return false
-        return contactRepository.hasContactFor(EmailAddress(senderEmailAddress))
+        return contactRepository.hasContactFor(senderEmailAddress)
     }
 
-    private fun getSenderEmailAddress(message: Message): String? {
+    private fun getSenderEmailAddress(message: Message): EmailAddress? {
         val from = message.from
         return if (from == null || from.isEmpty()) {
             null
         } else {
-            from[0].address
+            from[0].address.toEmailAddressOrNull()
         }
     }
 
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/ui/settings/KoinModule.kt b/app/ui/legacy/src/main/java/com/fsck/k9/ui/settings/KoinModule.kt
index eb055a03a1b3211ebf98beaef4ae70816649fe7b..68b9b9be7f4e1d285256f63f5429e2d61d80ae5e 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/ui/settings/KoinModule.kt
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/ui/settings/KoinModule.kt
@@ -32,6 +32,7 @@ val settingsUiModule = module {
             executorService = get(named("SaveSettingsExecutorService")),
             notificationChannelManager = get(),
             notificationController = get(),
+            messagingController = get(),
         )
     }
     factory { getSystemVibrator(context = get()) }
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/ui/settings/SettingsListFragment.kt b/app/ui/legacy/src/main/java/com/fsck/k9/ui/settings/SettingsListFragment.kt
index 75e96bfac14b6b99e969c061e618617ab462914a..1f56f7e75767e03e02e296566845a2cba9dbc67f 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/ui/settings/SettingsListFragment.kt
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/ui/settings/SettingsListFragment.kt
@@ -15,6 +15,10 @@ import androidx.navigation.fragment.findNavController
 import androidx.recyclerview.widget.ItemTouchHelper
 import androidx.recyclerview.widget.LinearLayoutManager
 import androidx.recyclerview.widget.RecyclerView
+import app.k9mail.core.featureflag.FeatureFlagKey
+import app.k9mail.core.featureflag.FeatureFlagProvider
+import app.k9mail.core.featureflag.FeatureFlagResult
+import app.k9mail.feature.launcher.FeatureLauncherActivity
 import com.fsck.k9.Account
 import com.fsck.k9.ui.R
 import com.fsck.k9.ui.helper.RecyclerViewBackgroundDrawable
@@ -28,10 +32,13 @@ import com.mikepenz.fastadapter.adapters.ItemAdapter
 import com.mikepenz.fastadapter.drag.ItemTouchCallback
 import com.mikepenz.fastadapter.drag.SimpleDragCallback
 import com.mikepenz.fastadapter.utils.DragDropUtil
+import org.koin.android.ext.android.inject
 import org.koin.androidx.viewmodel.ext.android.viewModel
+import timber.log.Timber
 
 class SettingsListFragment : Fragment(), ItemTouchCallback {
     private val viewModel: SettingsViewModel by viewModel()
+    private val featureFlagProvider: FeatureFlagProvider by inject()
 
     private lateinit var itemAdapter: ItemAdapter<GenericItem>
 
@@ -136,7 +143,16 @@ class SettingsListFragment : Fragment(), ItemTouchCallback {
         when (item) {
             is AccountItem -> launchAccountSettings(item.account)
             is UrlActionItem -> openUrl(item.url)
-            is SettingsActionItem -> findNavController().navigate(item.navigationAction)
+            is SettingsActionItem -> {
+                if (
+                    item.navigationAction == R.id.action_settingsListScreen_to_addAccountScreen &&
+                    featureFlagProvider.provide(FeatureFlagKey("new_onboarding")) is FeatureFlagResult.Enabled
+                ) {
+                    FeatureLauncherActivity.launchSetupAccount(requireActivity())
+                } else {
+                    findNavController().navigate(item.navigationAction)
+                }
+            }
         }
     }
 
@@ -154,10 +170,21 @@ class SettingsListFragment : Fragment(), ItemTouchCallback {
     }
 
     private fun launchOnboarding() {
-        findNavController().navigate(R.id.action_settingsListScreen_to_addAccountScreen)
+        featureFlagProvider.provide(FeatureFlagKey("new_onboarding")).onEnabled {
+            FeatureLauncherActivity.launchOnboarding(requireActivity())
+        }.onDisabled {
+            launchOldOnboarding()
+        }.onUnavailable {
+            Timber.d("Feature flag 'new_onboarding' is unavailable, falling back to old onboarding")
+            launchOldOnboarding()
+        }
         requireActivity().finishAffinity()
     }
 
+    private fun launchOldOnboarding() {
+        findNavController().navigate(R.id.action_settingsListScreen_to_addAccountScreen)
+    }
+
     private fun buildSettingsList(block: SettingsListBuilder.() -> Unit): List<GenericItem> {
         return SettingsListBuilder().apply(block).toList()
     }
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/ui/settings/account/AccountSettingsDataStore.kt b/app/ui/legacy/src/main/java/com/fsck/k9/ui/settings/account/AccountSettingsDataStore.kt
index 2414247812df3b3ded64145f900fe47705b4a324..eeab0854ca51bbc231708d7101c1a4e67a59279b 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/ui/settings/account/AccountSettingsDataStore.kt
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/ui/settings/account/AccountSettingsDataStore.kt
@@ -6,6 +6,7 @@ import com.fsck.k9.Account.SpecialFolderSelection
 import com.fsck.k9.NotificationLight
 import com.fsck.k9.NotificationVibration
 import com.fsck.k9.Preferences
+import com.fsck.k9.controller.MessagingController
 import com.fsck.k9.job.K9JobManager
 import com.fsck.k9.notification.NotificationChannelManager
 import com.fsck.k9.notification.NotificationController
@@ -18,6 +19,7 @@ class AccountSettingsDataStore(
     private val jobManager: K9JobManager,
     private val notificationChannelManager: NotificationChannelManager,
     private val notificationController: NotificationController,
+    private val messagingController: MessagingController,
 ) : PreferenceDataStore() {
     private var notificationSettingsChanged = false
 
@@ -41,6 +43,7 @@ class AccountSettingsDataStore(
             "autocrypt_prefer_encrypt" -> account.autocryptPreferEncryptMutual
             "upload_sent_messages" -> account.isUploadSentMessages
             "ignore_chat_messages" -> account.isIgnoreChatMessages
+            "subscribed_folders_only" -> account.isSubscribedFoldersOnly
             else -> defValue
         }
     }
@@ -65,6 +68,7 @@ class AccountSettingsDataStore(
             "autocrypt_prefer_encrypt" -> account.autocryptPreferEncryptMutual = value
             "upload_sent_messages" -> account.isUploadSentMessages = value
             "ignore_chat_messages" -> account.isIgnoreChatMessages = value
+            "subscribed_folders_only" -> updateSubscribedFoldersOnly(value)
             else -> return
         }
 
@@ -286,4 +290,12 @@ class AccountSettingsDataStore(
         }
         notificationSettingsChanged = true
     }
+
+    private fun updateSubscribedFoldersOnly(value: Boolean) {
+        if (account.isSubscribedFoldersOnly != value) {
+            account.isSubscribedFoldersOnly = value
+
+            messagingController.refreshFolderList(account)
+        }
+    }
 }
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/ui/settings/account/AccountSettingsDataStoreFactory.kt b/app/ui/legacy/src/main/java/com/fsck/k9/ui/settings/account/AccountSettingsDataStoreFactory.kt
index 11700a7cc5d2725204343b85da0c1f0b5eb985d8..ba749ecf7c485afacf3370083e30e4d513783830 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/ui/settings/account/AccountSettingsDataStoreFactory.kt
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/ui/settings/account/AccountSettingsDataStoreFactory.kt
@@ -2,6 +2,7 @@ package com.fsck.k9.ui.settings.account
 
 import com.fsck.k9.Account
 import com.fsck.k9.Preferences
+import com.fsck.k9.controller.MessagingController
 import com.fsck.k9.job.K9JobManager
 import com.fsck.k9.notification.NotificationChannelManager
 import com.fsck.k9.notification.NotificationController
@@ -13,6 +14,7 @@ class AccountSettingsDataStoreFactory(
     private val executorService: ExecutorService,
     private val notificationChannelManager: NotificationChannelManager,
     private val notificationController: NotificationController,
+    private val messagingController: MessagingController,
 ) {
     fun create(account: Account): AccountSettingsDataStore {
         return AccountSettingsDataStore(
@@ -22,6 +24,7 @@ class AccountSettingsDataStoreFactory(
             jobManager,
             notificationChannelManager,
             notificationController,
+            messagingController,
         )
     }
 }
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/ui/settings/account/AccountSettingsFragment.kt b/app/ui/legacy/src/main/java/com/fsck/k9/ui/settings/account/AccountSettingsFragment.kt
index 07817b7cf33700b44a12809a4b0f4904a6bb1bf3..fdc4d1ee52cafbb7aefb912ff88a8f9d2d43da51 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/ui/settings/account/AccountSettingsFragment.kt
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/ui/settings/account/AccountSettingsFragment.kt
@@ -349,6 +349,10 @@ class AccountSettingsFragment : PreferenceFragmentCompat(), ConfirmationDialogFr
 
     private fun initializeFolderSettings(account: Account) {
         findPreference<Preference>(PREFERENCE_FOLDERS)?.let {
+            if (!messagingController.supportsFolderSubscriptions(account)) {
+                findPreference<Preference>(PREFERENCE_SUBSCRIBED_FOLDERS_ONLY).remove()
+            }
+
             if (!messagingController.isMoveCapable(account)) {
                 findPreference<Preference>(PREFERENCE_ARCHIVE_FOLDER).remove()
                 findPreference<Preference>(PREFERENCE_DRAFTS_FOLDER).remove()
@@ -453,6 +457,7 @@ class AccountSettingsFragment : PreferenceFragmentCompat(), ConfirmationDialogFr
         private const val PREFERENCE_AUTOCRYPT_TRANSFER = "autocrypt_transfer"
         private const val PREFERENCE_FOLDERS = "folders"
         private const val PREFERENCE_AUTO_EXPAND_FOLDER = "account_setup_auto_expand_folder"
+        private const val PREFERENCE_SUBSCRIBED_FOLDERS_ONLY = "subscribed_folders_only"
         private const val PREFERENCE_ARCHIVE_FOLDER = "archive_folder"
         private const val PREFERENCE_DRAFTS_FOLDER = "drafts_folder"
         private const val PREFERENCE_SENT_FOLDER = "sent_folder"
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/ui/settings/import/SettingsImportFragment.kt b/app/ui/legacy/src/main/java/com/fsck/k9/ui/settings/import/SettingsImportFragment.kt
index 10bd1e9a66665a1f5dc2cf8fd6930012d4bdd07e..4789af6c608330545d0ec0f26f499b0386c7dddb 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/ui/settings/import/SettingsImportFragment.kt
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/ui/settings/import/SettingsImportFragment.kt
@@ -153,11 +153,16 @@ class SettingsImportFragment : Fragment() {
         }
     }
 
+    @Suppress("SwallowedException")
     private fun closeImportScreen(action: Action.Close) {
         if (action.importSuccess) {
             resultViewModel.setSettingsImportResult()
         }
-        findNavController().popBackStack()
+        try {
+            findNavController().popBackStack()
+        } catch (e: IllegalStateException) {
+            // Fragment does not have NavController
+        }
     }
 
     private fun pickDocument() {
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/view/KoinModule.kt b/app/ui/legacy/src/main/java/com/fsck/k9/view/KoinModule.kt
index 39f7fd1a65bddb115e66c977eb035352763602a8..89a209b7c2e4b5a228c1e4db56fa3dcad3120904 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/view/KoinModule.kt
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/view/KoinModule.kt
@@ -16,4 +16,5 @@ val viewModule = module {
         K9WebViewClient(clipboardManager = get(), attachmentResolver, onPageFinishedListener)
     }
     factory { WebViewClientFactory() }
+    factory { UserInputEmailAddressParser() }
 }
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/view/RecipientSelectView.java b/app/ui/legacy/src/main/java/com/fsck/k9/view/RecipientSelectView.java
index ea9118b7abad582d191c92381e543bf0840cc7f4..c34297c52e1f05cb1522b5a3229d15e856d07644 100644
--- a/app/ui/legacy/src/main/java/com/fsck/k9/view/RecipientSelectView.java
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/view/RecipientSelectView.java
@@ -33,6 +33,7 @@ import android.widget.ListPopupWindow;
 import android.widget.ListView;
 import android.widget.TextView;
 
+import com.fsck.k9.DI;
 import com.fsck.k9.K9;
 import com.fsck.k9.ui.R;
 import com.fsck.k9.activity.AlternateRecipientAdapter;
@@ -43,7 +44,6 @@ import com.fsck.k9.mail.Address;
 import com.fsck.k9.ui.compose.RecipientCircleImageView;
 import com.fsck.k9.view.RecipientSelectView.Recipient;
 import com.tokenautocomplete.TokenCompleteTextView;
-import org.apache.james.mime4j.util.CharsetUtil;
 import timber.log.Timber;
 import de.hdodenhof.circleimageview.CircleImageView;
 
@@ -61,6 +61,8 @@ public class RecipientSelectView extends TokenCompleteTextView<Recipient> implem
     private static final int LOADER_ID_ALTERNATES = 1;
 
 
+    private final UserInputEmailAddressParser emailAddressParser = DI.get(UserInputEmailAddressParser.class);
+
     private RecipientAdapter adapter;
     @Nullable
     private String cryptoProvider;
@@ -171,17 +173,19 @@ public class RecipientSelectView extends TokenCompleteTextView<Recipient> implem
 
     @Override
     protected Recipient defaultObject(String completionText) {
-        Address[] parsedAddresses = Address.parse(completionText);
-        if (!CharsetUtil.isASCII(completionText)) {
+        try {
+            List<Address> parsedAddresses = emailAddressParser.parse(completionText);
+
+            if (parsedAddresses.isEmpty()) {
+                setError(getContext().getString(R.string.recipient_error_parse_failed));
+                return null;
+            }
+
+            return new Recipient(parsedAddresses.get(0));
+        } catch (NonAsciiEmailAddressException e) {
             setError(getContext().getString(R.string.recipient_error_non_ascii));
             return null;
         }
-        if (parsedAddresses.length == 0 || parsedAddresses[0].getAddress() == null) {
-            setError(getContext().getString(R.string.recipient_error_parse_failed));
-            return null;
-        }
-
-        return new Recipient(parsedAddresses[0]);
     }
 
     public void setLoaderManager(@Nullable LoaderManager loaderManager) {
diff --git a/app/ui/legacy/src/main/java/com/fsck/k9/view/UserInputEmailAddressParser.kt b/app/ui/legacy/src/main/java/com/fsck/k9/view/UserInputEmailAddressParser.kt
new file mode 100644
index 0000000000000000000000000000000000000000..a14cb14bdb277abfae52045b613c1fbd740004b5
--- /dev/null
+++ b/app/ui/legacy/src/main/java/com/fsck/k9/view/UserInputEmailAddressParser.kt
@@ -0,0 +1,31 @@
+package com.fsck.k9.view
+
+import com.fsck.k9.mail.Address
+import org.apache.james.mime4j.util.CharsetUtil
+
+/**
+ * Used to parse name & email address pairs entered by the user.
+ *
+ * TODO: Build a custom implementation that can deal with typical inputs from users who are not familiar with the
+ *  RFC 5322 address-list syntax. See (ignored) tests in `UserInputEmailAddressParserTest`.
+ */
+internal class UserInputEmailAddressParser {
+
+    @Throws(NonAsciiEmailAddressException::class)
+    fun parse(input: String): List<Address> {
+        return Address.parseUnencoded(input)
+            .mapNotNull { address ->
+                when {
+                    address.isIncomplete() -> null
+                    address.isNonAsciiAddress() -> throw NonAsciiEmailAddressException(address.address)
+                    else -> Address.parse(address.toEncodedString()).firstOrNull()
+                }
+            }
+    }
+
+    private fun Address.isIncomplete() = hostname.isNullOrBlank()
+
+    private fun Address.isNonAsciiAddress() = !CharsetUtil.isASCII(address)
+}
+
+internal class NonAsciiEmailAddressException(message: String) : Exception(message)
diff --git a/app/ui/legacy/src/main/res/drawable/notification_icon_background_work.xml b/app/ui/legacy/src/main/res/drawable/notification_icon_background_work.xml
new file mode 100644
index 0000000000000000000000000000000000000000..54a93d36716eb9eee2d644f7ddd431e7b0ea0b32
--- /dev/null
+++ b/app/ui/legacy/src/main/res/drawable/notification_icon_background_work.xml
@@ -0,0 +1,10 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:tint="#FFFFFF"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M11,21h-1l1,-7H7.5c-0.58,0 -0.57,-0.32 -0.38,-0.66 0.19,-0.34 0.05,-0.08 0.07,-0.12C8.48,10.94 10.42,7.54 13,3h1l-1,7h3.5c0.49,0 0.56,0.33 0.47,0.51l-0.07,0.15C12.96,17.55 11,21 11,21z" />
+</vector>
diff --git a/app/ui/legacy/src/main/res/layout/about_library.xml b/app/ui/legacy/src/main/res/layout/about_library.xml
index 9d052387615448de13a3903062e540a0d4ae2d25..4177de52c13fd1e769ed60a8550f271f1d00ccbe 100644
--- a/app/ui/legacy/src/main/res/layout/about_library.xml
+++ b/app/ui/legacy/src/main/res/layout/about_library.xml
@@ -16,7 +16,7 @@
             android:id="@+id/name"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
-            android:textAppearance="@style/TextAppearance.AppCompat.Medium"
+            android:textAppearance="?android:attr/textAppearanceMedium"
             android:textColor="?android:attr/textColorPrimary"
             tools:text="Android Jetpack libraries" />
 
@@ -25,7 +25,7 @@
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
             android:layout_marginTop="4dp"
-            android:textAppearance="@style/TextAppearance.AppCompat.Small"
+            android:textAppearance="?android:attr/textAppearanceSmall"
             tools:text="Apache License, Version 2.0" />
 
 </LinearLayout>
diff --git a/app/ui/legacy/src/main/res/layout/account_setup_incoming.xml b/app/ui/legacy/src/main/res/layout/account_setup_incoming.xml
index 76adecb0f258573c362f12081ae2a047165d14f9..bc645d2829107f0a6a86ad305a297322b31b98a0 100644
--- a/app/ui/legacy/src/main/res/layout/account_setup_incoming.xml
+++ b/app/ui/legacy/src/main/res/layout/account_setup_incoming.xml
@@ -158,20 +158,6 @@
                 </com.google.android.material.textfield.TextInputLayout>
             </LinearLayout>
 
-            <LinearLayout
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content"
-                    android:id="@+id/imap_folder_setup_section"
-                    android:orientation="vertical">
-
-                <CheckBox
-                        android:id="@+id/subscribed_folders_only"
-                        android:layout_height="wrap_content"
-                        android:layout_width="wrap_content"
-                        android:text="@string/account_setup_incoming_subscribed_folders_only_label"
-                        />
-            </LinearLayout>
-
             <CheckBox
                     android:id="@+id/use_compression"
                     android:layout_height="wrap_content"
diff --git a/app/ui/legacy/src/main/res/layout/account_setup_oauth.xml b/app/ui/legacy/src/main/res/layout/account_setup_oauth.xml
index fae9a2d8f69ab9089a0c2dcdbd6bb2f38d0759f0..a373e73f64ee87a40f20a13324e4373c47d3eefd 100644
--- a/app/ui/legacy/src/main/res/layout/account_setup_oauth.xml
+++ b/app/ui/legacy/src/main/res/layout/account_setup_oauth.xml
@@ -37,7 +37,7 @@
                 android:text="@string/account_setup_oauth_sign_in"
                 android:visibility="gone" />
 
-            <Button
+            <androidx.appcompat.widget.AppCompatButton
                 android:id="@+id/google_sign_in_button"
                 android:layout_width="wrap_content"
                 android:layout_height="wrap_content"
diff --git a/app/ui/legacy/src/main/res/layout/accounts_item.xml b/app/ui/legacy/src/main/res/layout/accounts_item.xml
index b0895edb54db96f6efaa2af5de622b57d9c3edf8..521d029ccd9f87a2639f0efdb26e0d7b01921523 100644
--- a/app/ui/legacy/src/main/res/layout/accounts_item.xml
+++ b/app/ui/legacy/src/main/res/layout/accounts_item.xml
@@ -35,7 +35,7 @@
                 android:singleLine="true"
                 android:ellipsize="end"
                 android:textColor="?android:attr/textColorPrimary"
-                android:textAppearance="@style/TextAppearance.K9.Medium"
+                android:textSize="@dimen/appTextSizeMedium"
                 tools:text="@sample/accounts.json/data/name"/>
 
         <TextView
@@ -45,7 +45,7 @@
                 android:singleLine="true"
                 android:ellipsize="end"
                 android:textColor="?android:attr/textColorSecondary"
-                android:textAppearance="@style/TextAppearance.K9.Small"
+                android:textSize="@dimen/appTextSizeSmaller"
                 tools:text="@sample/accounts.json/data/email"/>
 
     </LinearLayout>
diff --git a/app/ui/legacy/src/main/res/layout/activity_fragment_launcher.xml b/app/ui/legacy/src/main/res/layout/activity_fragment_launcher.xml
new file mode 100644
index 0000000000000000000000000000000000000000..c96ef87208bc8e6047ec41fd644433ee0efdfda7
--- /dev/null
+++ b/app/ui/legacy/src/main/res/layout/activity_fragment_launcher.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical"
+    tools:context="com.fsck.k9.activity.FragmentLauncherActivity">
+
+    <include layout="@layout/toolbar" />
+
+    <androidx.fragment.app.FragmentContainerView
+        android:id="@+id/fragment_launcher_container"
+        android:layout_width="match_parent"
+        android:layout_height="0dp"
+        android:layout_weight="1"
+        />
+
+</LinearLayout>
diff --git a/app/ui/legacy/src/main/res/layout/changelog_list_change_item.xml b/app/ui/legacy/src/main/res/layout/changelog_list_change_item.xml
index 2c852e330a1b3819e9b22722316c0e0ea6b6673a..55aac9df557ce9d00b0b73b1fc74b7212509ba33 100644
--- a/app/ui/legacy/src/main/res/layout/changelog_list_change_item.xml
+++ b/app/ui/legacy/src/main/res/layout/changelog_list_change_item.xml
@@ -13,7 +13,7 @@
         android:paddingEnd="4dp"
         android:paddingBottom="4dp"
         android:text="•"
-        android:textAppearance="@style/TextAppearance.AppCompat.Body1"
+        android:textAppearance="?attr/textAppearanceBody2"
         tools:ignore="HardcodedText" />
 
     <TextView
@@ -25,6 +25,6 @@
         android:paddingStart="0dp"
         android:paddingEnd="16dp"
         android:paddingBottom="4dp"
-        android:textAppearance="@style/TextAppearance.AppCompat.Body1"
+        android:textAppearance="?attr/textAppearanceBody2"
         tools:text="Bug fixes and minor improvements" />
 </LinearLayout>
diff --git a/app/ui/legacy/src/main/res/layout/changelog_list_release_item.xml b/app/ui/legacy/src/main/res/layout/changelog_list_release_item.xml
index c821da6c92ab82bfae3ac51c8ceec54c9fca26e2..11df3b67b532f8de76a068bbf74c4a4123f93604 100644
--- a/app/ui/legacy/src/main/res/layout/changelog_list_release_item.xml
+++ b/app/ui/legacy/src/main/res/layout/changelog_list_release_item.xml
@@ -15,7 +15,7 @@
         android:paddingTop="8dp"
         android:paddingEnd="8dp"
         android:paddingBottom="8dp"
-        android:textAppearance="@style/TextAppearance.AppCompat.Title"
+        android:textAppearance="?attr/textAppearanceHeadline6"
         tools:text="Version 1.0.0" />
 
     <TextView
@@ -26,6 +26,6 @@
         android:paddingTop="8dp"
         android:paddingEnd="16dp"
         android:paddingBottom="8dp"
-        android:textAppearance="@style/TextAppearance.AppCompat.Small"
+        android:textAppearance="?android:attr/textAppearanceSmall"
         tools:text="2021-01-21" />
 </LinearLayout>
diff --git a/app/ui/legacy/src/main/res/layout/fragment_about.xml b/app/ui/legacy/src/main/res/layout/fragment_about.xml
index 89880ba7e8978f6c76511d39c6ecbd1b44738b06..5eed2b93887557f864f81c5d3206f2d71db3f2ce 100644
--- a/app/ui/legacy/src/main/res/layout/fragment_about.xml
+++ b/app/ui/legacy/src/main/res/layout/fragment_about.xml
@@ -26,7 +26,7 @@
             android:paddingTop="16dp"
             android:paddingBottom="8dp"
             android:text="@string/about_title"
-            android:textAppearance="@style/TextAppearance.AppCompat.Body2"
+            android:textAppearance="?attr/textAppearanceSubtitle2"
             android:textColor="?attr/colorAccent" />
 
         <LinearLayout
@@ -197,7 +197,7 @@
             android:paddingTop="16dp"
             android:paddingBottom="8dp"
             android:text="@string/about_project_title"
-            android:textAppearance="@style/TextAppearance.AppCompat.Body2"
+            android:textAppearance="?attr/textAppearanceSubtitle2"
             android:textColor="?attr/colorAccent" />
 
         <LinearLayout
@@ -368,7 +368,7 @@
             android:paddingTop="16dp"
             android:paddingBottom="8dp"
             android:text="@string/about_libraries"
-            android:textAppearance="@style/TextAppearance.AppCompat.Body2"
+            android:textAppearance="?attr/textAppearanceSubtitle2"
             android:textColor="?attr/colorAccent" />
 
         <androidx.recyclerview.widget.RecyclerView
diff --git a/app/ui/legacy/src/main/res/layout/fragment_changelog.xml b/app/ui/legacy/src/main/res/layout/fragment_changelog.xml
index e81f69c089023cf86da41a6b8cc94a6ed577d2e8..d2cf7de40a956616104d1163a66b5d7329784c1c 100644
--- a/app/ui/legacy/src/main/res/layout/fragment_changelog.xml
+++ b/app/ui/legacy/src/main/res/layout/fragment_changelog.xml
@@ -11,24 +11,23 @@
         android:id="@+id/changelog_list"
         android:layout_width="match_parent"
         android:layout_height="0dp"
-        android:layout_marginBottom="8dp"
         android:overScrollMode="ifContentScrolls"
         android:scrollbars="vertical"
         app:layoutManager="androidx.recyclerview.widget.LinearLayoutManager"
-        app:layout_constraintBottom_toTopOf="@+id/show_recent_changes_checkbox"
+        app:layout_constraintBottom_toTopOf="@+id/bottomBar"
         app:layout_constraintTop_toTopOf="parent"
         tools:visibility="visible"
         tools:listitem="@layout/changelog_list_release_item"/>
 
     <ProgressBar
         android:id="@+id/changelog_loading"
-        style="@style/Widget.AppCompat.ProgressBar"
+        style="?attr/progressBarStyle"
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
         android:layout_gravity="center"
         android:indeterminate="true"
         android:visibility="gone"
-        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintBottom_toTopOf="@id/bottomBar"
         app:layout_constraintEnd_toEndOf="parent"
         app:layout_constraintStart_toStartOf="parent"
         app:layout_constraintTop_toTopOf="parent"
@@ -41,34 +40,30 @@
         android:layout_gravity="center"
         android:text="@string/changelog_loading_error"
         android:visibility="gone"
-        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintBottom_toTopOf="@id/bottomBar"
         app:layout_constraintEnd_toEndOf="parent"
         app:layout_constraintStart_toStartOf="parent"
         app:layout_constraintTop_toTopOf="parent"
         tools:visibility="gone" />
 
-    <View
+    <FrameLayout
         android:id="@+id/bottomBar"
         android:layout_width="0dp"
-        android:layout_height="0dp"
+        android:layout_height="wrap_content"
         android:background="?attr/bottomBarBackground"
         android:elevation="8dp"
         app:layout_constraintBottom_toBottomOf="parent"
         app:layout_constraintEnd_toEndOf="parent"
-        app:layout_constraintStart_toStartOf="parent"
-        app:layout_constraintTop_toBottomOf="@+id/changelog_list" />
+        app:layout_constraintStart_toStartOf="parent">
+
+        <CheckBox
+            android:id="@+id/show_recent_changes_checkbox"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_marginHorizontal="16dp"
+            android:layout_marginVertical="8dp"
+            android:text="@string/changelog_show_recent_changes" />
+
+    </FrameLayout>
 
-    <CheckBox
-        android:id="@+id/show_recent_changes_checkbox"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:layout_marginStart="16dp"
-        android:layout_marginEnd="16dp"
-        android:layout_marginBottom="8dp"
-        android:elevation="8dp"
-        android:text="@string/changelog_show_recent_changes"
-        app:layout_constraintBottom_toBottomOf="parent"
-        app:layout_constraintEnd_toEndOf="parent"
-        app:layout_constraintHorizontal_bias="0.0"
-        app:layout_constraintStart_toStartOf="parent" />
 </androidx.constraintlayout.widget.ConstraintLayout>
diff --git a/app/ui/legacy/src/main/res/layout/fragment_settings_export.xml b/app/ui/legacy/src/main/res/layout/fragment_settings_export.xml
index 412f786d001b1afe83a10bbb2613b433b85150cd..37bda2f5dded2d621b8f330186e842a2b6ff554b 100644
--- a/app/ui/legacy/src/main/res/layout/fragment_settings_export.xml
+++ b/app/ui/legacy/src/main/res/layout/fragment_settings_export.xml
@@ -21,7 +21,6 @@
         android:id="@+id/bottomBar"
         android:layout_width="match_parent"
         android:layout_height="wrap_content"
-        android:background="?attr/bottomBarBackground"
         android:elevation="8dp"
         android:minHeight="56dp"
         app:layout_constraintBottom_toBottomOf="parent"
@@ -29,7 +28,6 @@
 
         <Button
             android:id="@+id/exportButton"
-            style="@style/Widget.AppCompat.Button.Colored"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
             android:layout_marginTop="4dp"
@@ -37,22 +35,21 @@
             android:layout_marginBottom="4dp"
             android:enabled="false"
             android:text="@string/settings_export_button"
-            android:textColor="@android:color/white"
-            app:layout_constraintBottom_toBottomOf="parent"
+            android:backgroundTint="@color/btn_color_bg_state"
+            android:textColor="@color/color_default_background"            app:layout_constraintBottom_toBottomOf="parent"
             app:layout_constraintEnd_toEndOf="parent"
             app:layout_constraintTop_toTopOf="parent" />
 
         <Button
             android:id="@+id/shareButton"
-            style="@style/Widget.AppCompat.Button.Colored"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
             android:layout_marginTop="4dp"
             android:layout_marginEnd="8dp"
             android:layout_marginBottom="4dp"
             android:text="@string/settings_export_share_button"
-            android:textColor="@android:color/white"
-            android:visibility="gone"
+            android:backgroundTint="@color/btn_color_bg_state"
+            android:textColor="@color/color_default_background"            android:visibility="gone"
             app:layout_constraintBottom_toBottomOf="parent"
             app:layout_constraintEnd_toEndOf="parent"
             app:layout_constraintTop_toTopOf="parent" />
diff --git a/app/ui/legacy/src/main/res/layout/fragment_settings_import.xml b/app/ui/legacy/src/main/res/layout/fragment_settings_import.xml
index e340107ef85d7703a7d8fa8d31df53a18f067356..568471e2380197cc089c198440f28bc76c56df25 100644
--- a/app/ui/legacy/src/main/res/layout/fragment_settings_import.xml
+++ b/app/ui/legacy/src/main/res/layout/fragment_settings_import.xml
@@ -20,7 +20,6 @@
 
     <Button
         android:id="@+id/pickDocumentButton"
-        style="@style/Widget.AppCompat.Button.Colored"
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
         android:layout_marginStart="16dp"
@@ -28,7 +27,8 @@
         android:layout_marginEnd="16dp"
         android:layout_marginBottom="16dp"
         android:text="@string/settings_import_pick_document_button"
-        android:textColor="@android:color/white"
+        android:backgroundTint="@color/btn_color_bg_state"
+        android:textColor="@color/color_default_background"
         app:layout_constraintBottom_toTopOf="@+id/bottomBar"
         app:layout_constraintEnd_toEndOf="parent"
         app:layout_constraintStart_toStartOf="parent"
@@ -50,14 +50,12 @@
         android:id="@+id/bottomBar"
         android:layout_width="match_parent"
         android:layout_height="wrap_content"
-        android:background="?attr/bottomBarBackground"
         android:minHeight="56dp"
         app:layout_constraintBottom_toBottomOf="parent"
         tools:ignore="UnusedAttribute">
 
         <Button
             android:id="@+id/importButton"
-            style="@style/Widget.AppCompat.Button.Colored"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
             android:layout_marginTop="4dp"
@@ -65,22 +63,22 @@
             android:layout_marginBottom="4dp"
             android:enabled="false"
             android:text="@string/settings_import_button"
-            android:textColor="@android:color/white"
-            app:layout_constraintBottom_toBottomOf="parent"
+            android:backgroundTint="@color/btn_color_bg_state"
+            android:textColor="@color/color_default_background"            app:layout_constraintBottom_toBottomOf="parent"
             app:layout_constraintEnd_toEndOf="parent"
             app:layout_constraintTop_toTopOf="parent"
             app:layout_constraintStart_toEndOf="@id/buttonBarrier" />
 
         <Button
             android:id="@+id/closeButton"
-            style="@style/Widget.AppCompat.Button.Colored"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
             android:layout_marginTop="4dp"
             android:layout_marginEnd="8dp"
             android:layout_marginBottom="4dp"
             android:text="@string/okay_action"
-            android:textColor="@android:color/white"
+            android:backgroundTint="@color/btn_color_bg_state"
+            android:textColor="@color/color_default_background"
             android:visibility="gone"
             app:layout_constraintBottom_toBottomOf="parent"
             app:layout_constraintEnd_toEndOf="parent"
diff --git a/app/ui/legacy/src/main/res/layout/message.xml b/app/ui/legacy/src/main/res/layout/message.xml
index 48efec8921660650baa288507a8f984f4d7e8c95..83ceb730a8f00fea42f7ea6b9525ca5aa8667913 100644
--- a/app/ui/legacy/src/main/res/layout/message.xml
+++ b/app/ui/legacy/src/main/res/layout/message.xml
@@ -36,7 +36,7 @@
 
                 <Button
                     android:id="@+id/show_pictures"
-                    style="@style/Widget.MaterialComponents.Button.OutlinedButton"
+                    style="?attr/materialButtonOutlinedStyle"
                     android:layout_width="wrap_content"
                     android:layout_height="wrap_content"
                     android:layout_gravity="center_horizontal"
@@ -103,7 +103,7 @@
     </com.fsck.k9.view.NonLockingScrollView>
 
     <Button android:id="@+id/download_remainder"
-        style="@style/Widget.MaterialComponents.Button.OutlinedButton"
+        style="?attr/materialButtonOutlinedStyle"
         android:layout_marginHorizontal="16dp"
         android:text="@string/message_view_download_remainder"
         android:textColor="@android:color/white"
diff --git a/app/ui/legacy/src/main/res/layout/message_details_participant_item.xml b/app/ui/legacy/src/main/res/layout/message_details_participant_item.xml
index 3c9f04f643304c9ea167f6b20e98e2ec1b475aa9..cfbe1c46323a4060753eca3b45fe907847607070 100644
--- a/app/ui/legacy/src/main/res/layout/message_details_participant_item.xml
+++ b/app/ui/legacy/src/main/res/layout/message_details_participant_item.xml
@@ -43,7 +43,7 @@
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
         android:layout_marginEnd="4dp"
-        android:textAppearance="@style/TextAppearance.MaterialComponents.Body2"
+        android:textAppearance="?attr/textAppearanceBody2"
         android:textColor="?android:attr/textColorSecondary"
         android:layout_marginStart="16dp"
         app:layout_constrainedWidth="true"
diff --git a/app/ui/legacy/src/main/res/layout/message_list.xml b/app/ui/legacy/src/main/res/layout/message_list.xml
index cd6ed7d98b800e9e6b4233d7f35478a67833c51e..5540d378be7a643056d55908cd282173cadeded2 100644
--- a/app/ui/legacy/src/main/res/layout/message_list.xml
+++ b/app/ui/legacy/src/main/res/layout/message_list.xml
@@ -20,7 +20,7 @@
 
         <ProgressBar
             android:id="@+id/message_list_progress"
-            style="@style/Widget.AppCompat.ProgressBar.Horizontal"
+            style="?android:attr/progressBarStyleHorizontal"
             android:layout_width="match_parent"
             android:layout_height="wrap_content"
             android:layout_below="@id/toolbar"
diff --git a/app/ui/legacy/src/main/res/layout/message_view_header.xml b/app/ui/legacy/src/main/res/layout/message_view_header.xml
index d3980ce74431cc5726b4ea75eefa649900569a52..749f3e551726e77325c68ddff8dde42e34c53c1b 100644
--- a/app/ui/legacy/src/main/res/layout/message_view_header.xml
+++ b/app/ui/legacy/src/main/res/layout/message_view_header.xml
@@ -118,7 +118,7 @@
             android:ellipsize="end"
             android:gravity="center_vertical"
             android:maxLines="1"
-            android:textAppearance="@style/TextAppearance.MaterialComponents.Body1"
+            android:textAppearance="?attr/textAppearanceBody1"
             android:textColor="?android:attr/textColorPrimary"
             app:layout_constrainedWidth="true"
             app:layout_constraintEnd_toStartOf="@+id/date"
diff --git a/app/ui/legacy/src/main/res/layout/message_view_headers.xml b/app/ui/legacy/src/main/res/layout/message_view_headers.xml
index 02e39c0ccac3730a02a011056270c3c0469174ce..28a951fce5adca1bd4adf8b450492e0b66dc6a71 100644
--- a/app/ui/legacy/src/main/res/layout/message_view_headers.xml
+++ b/app/ui/legacy/src/main/res/layout/message_view_headers.xml
@@ -28,7 +28,7 @@
 
     <ProgressBar
         android:id="@+id/message_headers_loading"
-        style="@style/Widget.AppCompat.ProgressBar"
+        style="?attr/progressBarStyle"
         android:layout_width="wrap_content"
         android:layout_height="wrap_content"
         android:layout_gravity="center"
diff --git a/app/ui/legacy/src/main/res/layout/recipient_names.xml b/app/ui/legacy/src/main/res/layout/recipient_names.xml
index c83217443dc1ff99dc116b62110ead15758713f3..8bb2a8a1a50f40322336e778ccdecf2889d854b4 100644
--- a/app/ui/legacy/src/main/res/layout/recipient_names.xml
+++ b/app/ui/legacy/src/main/res/layout/recipient_names.xml
@@ -10,7 +10,7 @@
         android:layout_height="wrap_content"
         android:ellipsize="end"
         android:maxLines="1"
-        android:textAppearance="@style/TextAppearance.MaterialComponents.Body2"
+        android:textAppearance="?attr/textAppearanceBody2"
         android:textColor="?android:attr/textColorSecondary"
         tools:text="to me" />
 
@@ -20,7 +20,7 @@
         android:layout_height="wrap_content"
         android:layout_marginStart="4dp"
         android:singleLine="true"
-        android:textAppearance="@style/TextAppearance.MaterialComponents.Body2"
+        android:textAppearance="?attr/textAppearanceBody2"
         android:textColor="?attr/colorAccent"
         tools:text="+2" />
 
diff --git a/app/ui/legacy/src/main/res/layout/split_message_list.xml b/app/ui/legacy/src/main/res/layout/split_message_list.xml
index 760c2b16e5c15a34f8df5cc9e931cdee28142acf..1df332838b45d50d98cd63e6f5e1a21ac150b887 100644
--- a/app/ui/legacy/src/main/res/layout/split_message_list.xml
+++ b/app/ui/legacy/src/main/res/layout/split_message_list.xml
@@ -20,7 +20,7 @@
 
         <ProgressBar
             android:id="@+id/message_list_progress"
-            style="@style/Widget.AppCompat.ProgressBar.Horizontal"
+            style="?android:attr/progressBarStyleHorizontal"
             android:layout_width="match_parent"
             android:layout_height="wrap_content"
             android:layout_below="@id/toolbar"
diff --git a/app/ui/legacy/src/main/res/layout/swipe_left_action.xml b/app/ui/legacy/src/main/res/layout/swipe_left_action.xml
index 93400abc45cbf5a8761d5c373418ad855b186ba2..c54819b950c4b36fe68e3b31822f98c412b21ad0 100644
--- a/app/ui/legacy/src/main/res/layout/swipe_left_action.xml
+++ b/app/ui/legacy/src/main/res/layout/swipe_left_action.xml
@@ -35,7 +35,7 @@
         android:ellipsize="end"
         android:gravity="right"
         android:maxLines="1"
-        android:textAppearance="@style/TextAppearance.AppCompat.Body1"
+        android:textAppearance="?attr/textAppearanceBody2"
         android:textColor="?attr/messageListSwipeIconTint"
         app:layout_constrainedWidth="true"
         app:layout_constraintBottom_toBottomOf="parent"
diff --git a/app/ui/legacy/src/main/res/layout/swipe_right_action.xml b/app/ui/legacy/src/main/res/layout/swipe_right_action.xml
index d9ce8383adcef95a4a38e8b0d655efaba8f5de5f..248c431e18cb4dbfa7cc87328df6952028630ac2 100644
--- a/app/ui/legacy/src/main/res/layout/swipe_right_action.xml
+++ b/app/ui/legacy/src/main/res/layout/swipe_right_action.xml
@@ -35,7 +35,7 @@
         android:ellipsize="end"
         android:gravity="left"
         android:maxLines="1"
-        android:textAppearance="@style/TextAppearance.AppCompat.Body1"
+        android:textAppearance="?attr/textAppearanceBody2"
         android:textColor="?attr/messageListSwipeIconTint"
         app:layout_constrainedWidth="true"
         app:layout_constraintBottom_toBottomOf="parent"
diff --git a/app/ui/legacy/src/main/res/raw/changelog_master.xml b/app/ui/legacy/src/main/res/raw/changelog_master.xml
index e89efbbdc60ec8268bfa2f75a17b1685848293a2..f204abf9630791dd8f8b5b90d69412970a6c0d51 100644
--- a/app/ui/legacy/src/main/res/raw/changelog_master.xml
+++ b/app/ui/legacy/src/main/res/raw/changelog_master.xml
@@ -5,6 +5,47 @@
      Locale-specific versions are kept in res/raw-<locale qualifier>/changelog.xml.
 -->
 <changelog>
+    <release version="6.710" versioncode="37010" date="2023-08-18">
+        <change>Fixed bug where accounts using OAuth weren't set up properly in K-9 Mail 6.709</change>
+        <change>Moved "Show only subscribed folders" setting to "Folders" section</change>
+    </release>
+    <release version="6.709" versioncode="37009" date="2023-08-14">
+        <change>Enabled the new and improved account setup flow</change>
+    </release>
+    <release version="6.708" versioncode="37008" date="2023-08-08">
+        <change>Changed compose icon in the message list widget to match the icon inside the app</change>
+        <change>Added information about the read state of a message to the data read by screen readers</change>
+        <change>A URI pasted when composing a message will now be surrounded by angle brackets</change>
+        <change>Improved error handling in many situations</change>
+        <change>Fixed bug where account name wasn't displayed in the message view when it should</change>
+        <change>Fixed inconsistent behavior when replying to messages</change>
+        <change>Fixed bug when saving a draft message using an identity without a display name</change>
+        <change>Fixed display issue when removing an account</change>
+        <change>Quite a few internal changes</change>
+        <change>Updated translations</change>
+    </release>
+    <release version="6.707" versioncode="37007" date="2023-06-19">
+        <change>Fixed bug where navigating to a different screen after using the system back button/gesture could crash the app</change>
+    </release>
+    <release version="6.706" versioncode="37006" date="2023-06-16">
+        <change>Fixed a bug that lead to folders appearing to be empty</change>
+        <change>Don't use nickname as display name when auto-completing recipient using the nickname</change>
+    </release>
+    <release version="6.705" versioncode="37005" date="2023-06-12">
+        <change>Adding to contacts should now allow you again to add the email address to an existing contact</change>
+        <change>Fixed display issue with recipients in message view screen</change>
+        <change>Fixed appearance of "Sign in with Google" button</change>
+        <change>Fixed bugs with importing and exporting identities</change>
+        <change>Manually entering names containing non-latin characters is now possible when composing messages</change>
+        <change>The app will no longer ask to save a draft when no changes have been made to an existing draft message</change>
+        <change>Updated translations</change>
+    </release>
+    <release version="6.704" versioncode="37004" date="2023-05-23">
+        <change>Changed primary action in message view header from "reply all" to "reply"</change>
+        <change>Fixed the app so it runs on devices that don't support home screen widgets</change>
+        <change>Fixed bug where "Cannot connect to crypto provider" was displayed when the problem wasn't the crypto provider</change>
+        <change>Updated translations</change>
+    </release>
     <release version="6.703" versioncode="37003" date="2023-05-08">
         <change>Internal changes</change>
         <change>Updated translations</change>
@@ -24,6 +65,9 @@
         <change>Fixed various crashes</change>
         <change>Updated translations</change>
     </release>
+    <release version="6.602" versioncode="36002" date="2023-05-11">
+        <change>Change primary action in message view header from "reply all" to "reply"</change>
+    </release>
     <release version="6.601" versioncode="36001" date="2023-04-18">
         <change>Reverted changes to home screen widgets because apparently not every device vendor has incorporated the relevant fixes in Android 12+</change>
     </release>
diff --git a/app/ui/legacy/src/main/res/values-ar/strings.xml b/app/ui/legacy/src/main/res/values-ar/strings.xml
index 5b989cfbfb7e5ecbef95fb848de38c52ea1d637a..43aeb8b7f4298fa2a28c5a110c5ba7e277c056f0 100644
--- a/app/ui/legacy/src/main/res/values-ar/strings.xml
+++ b/app/ui/legacy/src/main/res/values-ar/strings.xml
@@ -786,4 +786,338 @@
     <!--A user visible label for the email address copied to the clipboard-->
     <string name="clipboard_label_email_address">عناوين البريد</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
-</resources>
\ No newline at end of file
+  <string name="source_code">الكود المصدري</string>
+  <string name="about_project_title">مشروع مفتوح المصدر</string>
+  <string name="about_website_title">الموقع الإلكتروني</string>
+  <string name="user_manual_title">دليل المستخدم</string>
+  <string name="get_help_title">الحصول علي مساعدة</string>
+  <string name="user_forum_title">منتدى المستخدم </string>
+  <string name="about_fediverse_title">Fediverse </string>
+  <string name="about_twitter_title">تويتر</string>
+  <string name="changelog_loading_error">تعذر تحميل سجل التغيير</string>
+  <string name="changelog_version_title">الإصدار %s</string>
+  <string name="changelog_show_recent_changes">إظهار التغييرات الأخيرة عندما تم تحديث التطبيق</string>
+  <!--Displayed in a "snack bar" at the bottom of the screen when the app was updated.-->
+  <string name="changelog_snackbar_text">اكتشف الجديد في هذا الإصدار</string>
+  <!--Button text of the "snack bar" that is displayed when the app was updated.-->
+  <string name="changelog_snackbar_button_text">عرض</string>
+  <!--Welcome message-->
+  <string name="choose_folder_move_title">نقل إلي</string>
+  <string name="choose_folder_copy_title">نسخ إلي</string>
+  <string name="new_messages_title">الرسائل الجديدة</string>
+  <string name="unsubscribe_action">إلغاء الاشتراك</string>
+  <string name="copy_subject_to_clipboard">تم نسخ نص الموضوع إلى الحافظة</string>
+  <string name="notification_additional_messages">+<xliff:g id="additional_messages">%1$d</xliff:g> المزيد علي <xliff:g id="account">%2$s</xliff:g></string>
+  <string name="notification_certificate_error_public">خطأ في الشهادة</string>
+  <!--Title of an error notification that is displayed when creating a notification for a new message has failed-->
+  <string name="notification_notify_error_title">إشعار خطأ</string>
+  <!--Body of an error notification that is displayed when creating a notification for a new message has failed-->
+  <string name="notification_notify_error_text">حدث خطأ أثناء محاولة إنشاء إشعار نظام برسالة جديدة. السبب على الأرجح هو فقدان صوت الإشعار. \ n \ n انقر لفتح إعدادات الإشعارات.</string>
+  <string name="notification_channel_push_title">تزامن (إرسال)</string>
+  <string name="notification_channel_push_description">يتم عرضها أثناء انتظار رسائل جديدة</string>
+  <string name="debug_export_logs_title">سجلات التصدير</string>
+  <string name="debug_export_logs_success">تم التصدير بنجاح. قد تحتوي السجلات على معلومات حساسة. كن حذرًا لمن ترسلهم إليه.</string>
+  <string name="debug_export_logs_failure">فشل التصدير.</string>
+  <string name="compose_error_incomplete_recipient">يحتوي حقل المستلم على إدخال غير مكتمل!</string>
+  <!--Displayed in the message view screen in front of the recipient list. For most languages this should end with a space.-->
+  <string name="message_view_recipient_prefix">إلي</string>
+  <!--Displayed in the message view screen in front of the number of additional recipients (the ones that are not displayed).-->
+  <string name="message_view_additional_recipient_prefix">+</string>
+  <!--Displayed in the message view screen if the message was addressed to the user. Make sure this works with 'message_view_recipient_prefix'. In English it's "to me".-->
+  <string name="message_view_me_text">انا</string>
+  <!--Text of the button that is displayed below the message header when the message body references one or more remote images-->
+  <string name="message_view_show_remote_images_action">عرض الصور البعيدة</string>
+  <string name="global_settings_flag_summary">تشير النجوم إلى الرسائل التي تم وضع علامة عليها</string>
+  <string name="global_settings_sender_above_subject_summary">اعرض أسماء المراسلين فوق سطر الموضوع وليس تحته</string>
+  <string name="global_settings_show_contact_name_summary">استخدم أسماء المستلمين من جهات الاتصال عند توفرها</string>
+  <string name="general_settings_contact_name_color_label">Contact name color</string>
+  <string name="global_settings_messageview_fixedwidth_summary">استخدم خطًا ذا عرض ثابت عند إظهار رسائل نصية عادية</string>
+  <string name="global_settings_confirm_actions_summary">إظهار مربع حوار كلما قمت بتنفيذ الإجراءات المحددة</string>
+  <!--Title of the screen to configure swipe actions-->
+  <string name="general_settings_swipe_actions_title">Swipe actions </string>
+  <!--Name of the setting to configure the right swipe action-->
+  <string name="general_settings_right_swipe_title">Right swipe </string>
+  <!--Name of the setting to configure the left swipe action-->
+  <string name="general_settings_left_swipe_title">Left swipe</string>
+  <!--Name of the swipe action to select/deselect a message-->
+  <string name="general_settings_swipe_action_toggle_selection">تبديل التحديد </string>
+  <!--Name of the swipe action to mark as message as read/unread-->
+  <string name="general_settings_swipe_action_toggle_read">وضع علامة مقروء / غير مقروء </string>
+  <!--Name of the swipe action to add/remove a star-->
+  <string name="general_settings_swipe_action_toggle_star">Add/remove star</string>
+  <!--Title of the setting to specify the density of the message list-->
+  <string name="general_settings_message_list_density_title">كثافة </string>
+  <string name="general_settings_ui_density_compact">المدمج </string>
+  <string name="general_settings_ui_density_relaxed">استرخاء </string>
+  <string name="global_settings_privacy_hide_timezone_detail">استخدم التوقيت العالمي المنسق (UTC) بدلاً من المنطقة الزمنية المحلية في رؤوس البريد ورأس الرد </string>
+  <string name="quiet_time_description">تعطيل الرنين والطنين والوميض في الليل </string>
+  <string name="account_setup_oauth_description">لاستخدام حساب البريد الإلكتروني هذا مع K-9 Mail ، تحتاج إلى تسجيل الدخول ومنح التطبيق حق الوصول إلى رسائل البريد الإلكتروني الخاصة بك. </string>
+  <!--Displayed below the 'account_setup_oauth_description' text-->
+  <string name="account_setup_oauth_sign_in">تسجيل الدخول</string>
+  <!--Displayed below the 'account_setup_oauth_description' text-->
+  <string name="account_setup_oauth_sign_in_with_google">تسجيل الدخول بأستخدام جوجل</string>
+  <!--Please use the same translation for "screen lock" as is used in the 'Security' section in Android's settings app-->
+  <string name="account_setup_basics_show_password_need_lock">لعرض كلمة المرور الخاصة بك هنا ، قم بتمكين قفل الشاشة على هذا الجهاز. </string>
+  <string name="account_setup_basics_show_password_biometrics_title">تحقق من هويتك </string>
+  <string name="account_setup_basics_show_password_biometrics_subtitle">افتح القفل لعرض كلمة المرور الخاصة بك </string>
+  <string name="account_setup_check_settings_title"/>
+  <string name="account_setup_check_settings_retr_info_msg">استرداد معلومات الحساب \ u2026 </string>
+  <string name="account_setup_check_settings_check_incoming_msg">التحقق من إعدادات الخادم الوارد \ u2026 </string>
+  <string name="account_setup_check_settings_check_outgoing_msg">التحقق من إعدادات خادم الصادر… </string>
+  <string name="account_setup_check_settings_fetch">إحضار إعدادات الحساب … </string>
+  <string name="account_setup_auth_type_oauth2">OAuth 2.0 </string>
+  <string name="account_setup_incoming_use_compression">استخدم الضغط </string>
+  <string name="account_setup_incoming_send_client_id">أرسل معرّف العميل </string>
+  <string name="account_setup_incoming_autodetect_namespace_label">اكتشاف مساحة اسم IMAP تلقائيًا </string>
+  <string name="account_setup_incoming_subscribed_folders_only_label">إظهار المجلدات المشتركة فقط </string>
+  <string name="account_setup_bad_uri">إعداد غير صالح: <xliff:g id="err_mess">%s</xliff:g></string>
+  <string name="account_setup_options_mail_check_frequency_label">تردد استطلاع المجلد </string>
+  <string name="idle_refresh_period_label">تحديث اتصال IDLE </string>
+  <string name="move_copy_cannot_copy_unsynced_message">لا يمكن نسخ أو نقل رسالة غير متزامنة مع الخادم </string>
+  <string name="account_setup_failed_dlg_certificate_message_fmt">قدم الخادم شهادة SSL غير صالحة. في بعض الأحيان ، يكون هذا بسبب خطأ في تهيئة الخادم. في بعض الأحيان يكون ذلك بسبب محاولة شخص ما مهاجمتك أو مهاجمة خادم البريد الخاص بك. إذا لم تكن متأكدًا من الأمر ، فانقر فوق رفض واتصل بالأشخاص الذين يديرون خادم البريد الخاص بك. \ n \ n (<xliff:g id="error">%s</xliff:g>)</string>
+  <string name="account_setup_failed_dlg_server_message_fmt">لا يمكن الاتصال بالسيرفر. \ n (<xliff:g id="error">%s</xliff:g>)</string>
+  <string name="account_setup_failed_dlg_oauth_flow_canceled">تم إلغاء التفويض </string>
+  <string name="account_setup_failed_dlg_oauth_flow_failed">فشل التفويض مع الخطأ التالي: <xliff:g id="error">%s</xliff:g></string>
+  <string name="account_setup_failed_dlg_oauth_not_supported">OAuth 2.0 غير مدعوم حاليًا مع هذا الموفر. </string>
+  <string name="account_setup_failed_dlg_browser_not_found">تعذر على التطبيق العثور على متصفح لاستخدامه لمنح حق الوصول إلى حسابك </string>
+  <string name="account_settings_notify_sync_summary">إعلام في شريط الحالة أثناء فحص البريد </string>
+  <string name="account_settings_ignore_chat_messages_label">تجاهل رسائل الدردشة </string>
+  <string name="account_settings_ignore_chat_messages_summary">لا تعرض إشعارات للرسائل التي تنتمي إلى محادثة عبر البريد الإلكتروني </string>
+  <string name="account_settings_mark_message_as_read_on_delete_label">وضع علامة كمقروءة عند الحذف </string>
+  <string name="account_settings_mark_message_as_read_on_delete_summary">وضع علامة على رسالة كمقروءة عند حذفها </string>
+  <string name="account_settings_notification_channels_label">فئات الإشعارات</string>
+  <string name="account_settings_open_notification_settings_messages_summary">تكوين الإخطارات للرسائل الجديدة </string>
+  <string name="account_settings_open_notification_settings_miscellaneous_summary">تكوين إخطارات الخطأ والحالة </string>
+  <string name="account_settings_always_show_cc_bcc_label">اعرض دائمًا نسخة إلى / نسخة مخفية الوجهة </string>
+  <string name="account_settings_upload_sent_messages_label">تحميل الرسائل المرسلة </string>
+  <string name="account_settings_upload_sent_messages_summary">تحميل الرسائل إلى مجلد المرسل بعد الإرسال </string>
+  <string name="account_settings_crypto_key">تكوين مفتاح من طرف إلى طرف </string>
+  <string name="account_settings_crypto_summary_off">لم يتم تكوين تطبيق OpenPGP </string>
+  <string name="account_settings_crypto_encrypt_all_drafts">تخزين جميع المسودات مشفرة </string>
+  <string name="account_settings_crypto_encrypt_all_drafts_on">سيتم تخزين جميع المسودات مشفرة </string>
+  <string name="account_settings_crypto_encrypt_all_drafts_off">تشفير المسودات فقط إذا تم تمكين التشفير </string>
+  <string name="account_settings_mail_check_frequency_label">تردد استطلاع المجلد </string>
+  <string name="account_settings_color_summary">لون التمييز لهذا الحساب المستخدم في قائمة المجلدات والحسابات </string>
+  <string name="account_settings_autodownload_message_size_label">إحضار الرسائل حتى </string>
+  <string name="account_settings_folder_push_mode_label">دفع المجلدات </string>
+  <string name="account_settings_folder_target_mode_label">نقل / نسخ مجلدات الوجهة </string>
+  <string name="account_settings_sync_remote_deletetions_label">مزامنة عمليات حذف الخادم </string>
+  <string name="account_settings_openpgp_missing">تطبيق OpenPGP مفقود - هل تم إلغاء تثبيته؟ </string>
+  <string name="folder_settings_in_top_group_summary">اعرض بالقرب من أعلى قائمة المجلدات </string>
+  <string name="folder_settings_folder_sync_mode_label">Folder poll class</string>
+  <string name="folder_settings_folder_sync_mode_inherited">نفس فئة العرض </string>
+  <string name="folder_settings_folder_push_mode_label">فئة دفع المجلد </string>
+  <string name="folder_settings_folder_push_mode_inherited">نفس فئة الاستطلاع </string>
+  <string name="folder_settings_folder_notify_mode_inherited">نفس فئة الدفع </string>
+  <string name="account_settings_vibration">اهتزاز </string>
+  <string name="account_settings_vibrate_summary_disabled">معطل </string>
+  <string name="account_settings_notification_light_label">ضوء الإشعارات</string>
+  <string name="account_settings_notification_light_disabled">معطل</string>
+  <string name="account_settings_notification_light_default_color">اللون الافتراضي للنظام </string>
+  <string name="account_settings_notification_light_white">أبيض</string>
+  <string name="account_settings_notification_light_red">أحمر</string>
+  <string name="account_settings_notification_light_green">أخضر</string>
+  <string name="account_settings_notification_light_blue">أزرق</string>
+  <string name="account_settings_notification_light_yellow">أصفر</string>
+  <string name="account_settings_notification_light_cyan">ازرق سماوي </string>
+  <string name="account_settings_notification_light_magenta">أرجواني </string>
+  <string name="account_settings_composition_summary">تعيين الافتراضي الخاص بك من ، مخفية الوجهة والتوقيع </string>
+  <string name="account_settings_identities_summary">قم بإعداد عناوين وتوقيعات بديلة في \"من\" </string>
+  <string name="account_settings_always_bcc_label">جميع الرسائل المخفية إلى </string>
+  <string name="manage_identities_move_top_action">الانتقال إلى الأعلى / جعله افتراضيًا </string>
+  <string name="sort_sender_re_alpha">المرسل عكس الترتيب الأبجدي </string>
+  <string name="sort_by_arrival">وصول </string>
+  <string name="setting_theme_follow_system">استخدم النظام الافتراضي </string>
+  <string name="settings_message_theme_label">موضوع عرض الرسالة </string>
+  <string name="preference_search_no_results">لم يتم العثور على إعدادات </string>
+  <string name="settings_message_theme_selection_label">موضوع الرسالة الثابتة </string>
+  <string name="settings_message_theme_selection_summary_off">حدد موضوع عرض الرسالة أثناء عرض الرسالة </string>
+  <string name="settings_message_theme_selection_summary_on">استخدم سمة عرض رسالة ثابتة </string>
+  <string name="background_ops_auto_sync_only">عند تحديد \"المزامنة التلقائية\" </string>
+  <string name="account_setup_push_limit_label">أقصى عدد من المجلدات للتحقق مع الدفع </string>
+  <string name="animations_summary">استخدم تأثيرات بصرية مبهرجة </string>
+  <string name="show_unified_inbox_title">إظهار علبة الوارد الموحدة </string>
+  <string name="show_starred_count_title">إظهار العدد المميّز بنجمة </string>
+  <string name="folder_settings_include_in_integrated_inbox_summary">يتم عرض جميع الرسائل في صندوق الوارد الموحد </string>
+  <string name="account_settings_searchable_displayable">للعرض </string>
+  <string name="account_settings_automatic_special_folder">تلقائي (%s)</string>
+  <string name="font_size_message_view_recipients">المستلمون </string>
+  <string name="error_activity_not_found">لم يتم العثور على تطبيق مناسب لهذا الإجراء. </string>
+  <string name="save_or_discard_draft_message_changes">حفظ أو تجاهل التغييرات؟ </string>
+  <string name="dialog_confirm_clear_local_folder_title">مسح الرسائل المحلية؟ </string>
+  <string name="dialog_confirm_clear_local_folder_message">سيؤدي هذا إلى إزالة جميع الرسائل المحلية من المجلد. لن يتم حذف أي رسائل من الخادم. </string>
+  <string name="dialog_confirm_clear_local_folder_action">رسائل واضحة </string>
+  <string name="dialog_confirm_mark_all_as_read_title">تأكيد وضع علامة على الكل كمقروء </string>
+  <string name="settings_import_pick_document_button">اختيار ملف</string>
+  <string name="settings_import_success_generic">تم استيراد الإعدادات بنجاح </string>
+  <!--Displayed after importing accounts when one or multiple accounts require entering a password-->
+  <string name="settings_import_password_required">الرجاء إدخال كلمات المرور </string>
+  <!--Displayed after importing accounts when one or multiple accounts require to use the OAuth authorization flow-->
+  <string name="settings_import_authorization_required">الرجاء تسجيل الدخول </string>
+  <!--Displayed after importing accounts when some accounts require entering a password and some to use the OAuth authorization flow-->
+  <string name="settings_import_authorization_and_password_required">الرجاء تسجيل الدخول وإدخال كلمات المرور </string>
+  <string name="settings_import_failure">فشل استيراد الإعدادات </string>
+  <string name="settings_import_read_failure">فشلت قراءة ملف الإعدادات </string>
+  <string name="settings_import_partial_failure">فشل استيراد بعض الإعدادات </string>
+  <string name="settings_import_status_success">تم الاستيراد بنجاح </string>
+  <string name="settings_import_status_password_required">كلمة المرور مطلوبة </string>
+  <!--Content description for the icon that is displayed next to an imported account that requires sign-in-->
+  <string name="settings_import_status_log_in_required">تسجيل الدخول مطلوب </string>
+  <string name="settings_import_status_not_imported">غير مستورد </string>
+  <string name="settings_import_status_error">فشل الاستيراد </string>
+  <string name="settings_import_incoming_server_password_hint">كلمة مرور الخادم الواردة </string>
+  <string name="settings_import_outgoing_server_password_hint">كلمة مرور خادم البريد الصادر </string>
+  <string name="settings_import_use_same_password_for_outgoing_server">استخدم نفس كلمة المرور لخادم البريد الصادر </string>
+  <string name="unread_widget_select_account">إظهار العدد غير المقروء لـ … </string>
+  <string name="unread_widget_account_summary">الحساب الذي يجب عرض العدد غير المقروء له </string>
+  <string name="unread_widget_folder_enabled_summary">عرض العدد غير المقروء لمجلد واحد فقط </string>
+  <string name="unread_widget_folder_summary">المجلد الذي يجب عرض العدد غير المقروء له </string>
+  <string name="unread_widget_title"><xliff:g id="account_name">%1$s</xliff:g> - <xliff:g id="folder_name">%2$s</xliff:g></string>
+  <string name="webview_contextmenu_link_text_copy_action">انسخ نص الارتباط إلى الحافظة </string>
+  <string name="webview_contextmenu_link_text_clipboard_label">نص الارتباط </string>
+  <string name="account_settings_remote_search_num_label">حد بحث الخادم </string>
+  <string name="remote_search_error">فشل البحث عن بعد </string>
+  <string name="remote_search_unavailable_no_network">مطلوب اتصال شبكة للبحث عن الخادم. </string>
+  <string name="global_settings_background_as_unread_indicator_summary">ستظهر خلفية مختلفة أن الرسالة قد تمت قراءتها </string>
+  <string name="global_settings_threaded_view_label">عرض مترابطة </string>
+  <string name="global_settings_splitview_mode_label">عرض تقسيم الشاشة </string>
+  <string name="global_settings_splitview_when_in_landscape">عندما تكون في الاتجاه الأفقي </string>
+  <string name="message_view_empty">الرجاء تحديد رسالة على اليسار </string>
+  <string name="global_settings_show_contact_picture_summary">إظهار صور جهات الاتصال في قائمة الرسائل </string>
+  <string name="global_settings_messageview_visible_refile_actions_title">إجراءات الرسائل المرئية </string>
+  <string name="global_settings_messageview_visible_refile_actions_summary">إظهار الإجراءات المحددة في قائمة عرض الرسالة </string>
+  <string name="auth_external_error">غير قادر على مصادقة. لا يعلن الخادم عن إمكانية SASL EXTERNAL. قد يكون هذا بسبب مشكلة في شهادة العميل (منتهية الصلاحية ، مرجع مصدق غير معروف) أو مشكلة تكوين أخرى. </string>
+  <!--=== Client certificates specific ==================================================================-->
+  <string name="client_certificate_spinner_delete">إزالة اختيار شهادة العميل </string>
+  <string name="client_certificate_retrieval_failure">فشل استرداد شهادة العميل للاسم المستعار \"<xliff:g id="alias">%s</xliff:g>\"</string>
+  <string name="client_certificate_expired">شهادة العميل \"<xliff:g id="certificate_alias">%1$s</xliff:g>\" منتهية الصلاحية أو غير صالحة بعد (<xliff:g id="exception_message">%2$s</xliff:g>)</string>
+  <!--Note: This references message_view_download_remainder-->
+  <string name="add_from_contacts">إضافة من جهات الاتصال </string>
+  <string name="recipient_bcc">BCC</string>
+  <string name="reply_to_label">الرد على </string>
+  <string name="unknown_recipient">&lt;مستلم غير معروف&gt; </string>
+  <string name="unknown_sender">&lt;مرسل غير معروف&gt; </string>
+  <string name="compose_error_no_draft_folder">لم يتم تكوين مجلد مسودات لهذا الحساب! </string>
+  <string name="compose_error_no_key_configured">لم يتم تكوين مفتاح لهذا الحساب! تحقق من الإعدادات الخاصة بك. </string>
+  <string name="error_crypto_provider_incompatible">يستخدم موفر التشفير إصدارًا غير متوافق. يرجى التحقق من الإعدادات الخاصة بك! </string>
+  <string name="error_crypto_provider_connect">لا يمكن الاتصال بموفر التشفير ، تحقق من الإعدادات أو انقر فوق رمز التشفير لإعادة المحاولة! </string>
+  <string name="error_crypto_provider_ui_required">فشل في تهيئة التشفير من طرف إلى طرف ، يرجى التحقق من إعداداتك </string>
+  <string name="error_crypto_inline_attach">لا يدعم وضع PGP / INLINE المرفقات! </string>
+  <string name="enable_inline_pgp">تفعيل PGP / INLINE </string>
+  <string name="disable_inline_pgp">تعطيل PGP / INLINE </string>
+  <string name="enable_sign_only">تفعيل تسجيل PGP فقط </string>
+  <string name="disable_sign_only">تعطيل تسجيل PGP فقط </string>
+  <string name="openpgp_inline_title">وضع PGP / INLINE </string>
+  <string name="openpgp_inline_text">تم إرسال البريد الإلكتروني بتنسيق PGP / INLINE. \ n يجب استخدام هذا فقط من أجل التوافق: </string>
+  <string name="openpgp_inline_plus_compat">يدعم بعض العملاء هذا التنسيق فقط </string>
+  <string name="openpgp_inline_minus_transit">التوقيعات قد تنكسر أثناء العبور </string>
+  <string name="openpgp_dialog_sign_only_title">وضع تسجيل PGP فقط </string>
+  <string name="openpgp_dialog_sign_only_text">في هذا الوضع ، سيتم استخدام مفتاح PGP الخاص بك لإنشاء توقيع مشفر لبريد إلكتروني غير مشفر. </string>
+  <string name="openpgp_dialog_sign_only_plus_verified">لا يؤدي هذا إلى تشفير البريد الإلكتروني ، ولكنه يتحقق من أنه تم إرساله من مفتاحك. </string>
+  <string name="openpgp_dialog_sign_only_minus_break">قد تنقطع التوقيعات عند إرسالها إلى القوائم البريدية. </string>
+  <string name="crypto_msg_unencrypted_sign_error">احتوى التوقيع الشامل على خطأ </string>
+  <string name="crypto_msg_unsupported_signed">يحتوي على توقيع غير معتمد من طرف إلى طرف </string>
+  <string name="crypto_msg_unsupported_encrypted">الرسالة مشفرة ولكن بتنسيق غير مدعوم. </string>
+  <string name="crypto_msg_cancelled">تم تشفير الرسالة ، ولكن تم إلغاء فك التشفير. </string>
+  <string name="crypto_msg_title_unencrypted_signed_e2e">نص عادي موقع من طرف إلى طرف </string>
+  <string name="crypto_msg_unencrypted_sign_mismatch">لكن المفتاح من طرف إلى طرف لا يتطابق مع المرسل </string>
+  <string name="crypto_msg_unencrypted_sign_expired">لكن مفتاح النهاية إلى النهاية منتهي الصلاحية </string>
+  <string name="crypto_msg_unencrypted_sign_revoked">ولكن تم إبطال المفتاح من طرف إلى طرف </string>
+  <string name="crypto_msg_unencrypted_sign_insecure">لكن المفتاح من طرف إلى طرف لا يعتبر آمنًا </string>
+  <string name="crypto_msg_unencrypted_sign_unknown">من مفتاح طرف إلى طرف غير معروف </string>
+  <string name="crypto_msg_encrypted_error">ولكن كان هناك خطأ في فك التشفير </string>
+  <string name="crypto_msg_encrypted_incomplete">يجب تنزيل الرسالة بالكامل لفك التشفير </string>
+  <string name="crypto_msg_encrypted_no_provider">ولكن لم يتم تكوين تطبيق تشفير </string>
+  <string name="crypto_msg_encrypted_unsigned">ولكن ليس من طرف إلى طرف </string>
+  <string name="crypto_msg_title_encrypted_signed_e2e">تشفير من طرف إلى طرف </string>
+  <string name="crypto_msg_encrypted_sign_verified">من مرسل تم التحقق منه </string>
+  <string name="crypto_msg_encrypted_sign_unknown">من مفتاح طرف إلى طرف غير معروف </string>
+  <string name="crypto_msg_encrypted_sign_mismatch">لكن المفتاح من طرف إلى طرف لا يتطابق مع المرسل </string>
+  <string name="crypto_msg_encrypted_sign_expired">لكن مفتاح النهاية إلى النهاية منتهي الصلاحية</string>
+  <string name="crypto_msg_encrypted_sign_revoked">ولكن تم إبطال المفتاح من طرف إلى طرف </string>
+  <string name="crypto_msg_encrypted_sign_insecure">لكن المفتاح من طرف إلى طرف لا يعتبر آمنًا</string>
+  <string name="crypto_msg_encrypted_sign_error">لكن البيانات الشاملة بها أخطاء </string>
+  <string name="crypto_msg_encrypted_insecure">لكن التشفير لا يعتبر آمنًا </string>
+  <string name="locked_attach_unencrypted">لم يتم تشفير هذا الجزء ، وربما يكون غير آمن. </string>
+  <string name="messageview_decrypt_incomplete">يجب تنزيل الرسالة المشفرة لفك التشفير. </string>
+  <string name="recipient_error_non_ascii">الشخصيات الخاصة غير مدعومة حاليًا! </string>
+  <string name="recipient_error_parse_failed">خطأ في تحليل العنوان! </string>
+  <string name="account_settings_crypto_hide_sign_only">إخفاء التوقيعات غير المشفرة </string>
+  <string name="account_settings_crypto_hide_sign_only_on">سيتم عرض التوقيعات المشفرة فقط </string>
+  <string name="account_settings_crypto_hide_sign_only_off">سيتم عرض جميع التوقيعات </string>
+  <string name="error_sign_only_no_encryption">التشفير غير متوفر في وضع التسجيل فقط! </string>
+  <string name="crypto_no_provider_message">تم تشفير هذا البريد الإلكتروني باستخدام OpenPGP. \ n لقراءته ، تحتاج إلى تثبيت وتكوين تطبيق OpenPGP متوافق. </string>
+  <string name="crypto_no_provider_button">اذهب للاعدادات </string>
+  <!--Displayed in the the message list widget when the app hasn't had a chance to send content to it yet-->
+  <string name="openpgp_enabled_error_msg">بعض المستلمين المحددين لا يدعمون هذه الميزة! </string>
+  <string name="openpgp_description_text1">يضمن تشفير الرسائل إمكانية قراءتها من قبل المستلم ولا يمكن لأي شخص آخر قراءتها. </string>
+  <string name="openpgp_description_text3">سيظهر التشفير فقط إذا كان يدعمه جميع المستلمين ، ويجب أن يكونوا قد أرسلوا إليك بريدًا إلكترونيًا من قبل. </string>
+  <string name="openpgp_description_text2">تبديل التشفير عن طريق النقر فوق هذا الرمز. </string>
+  <string name="account_settings_crypto_prefer_encrypt">وضع التشفير التلقائي المتبادل </string>
+  <string name="dialog_autocrypt_mutual_title">وضع التشفير التلقائي المتبادل</string>
+  <string name="dialog_autocrypt_mutual_description_1">عادةً ما يتم تشفير الرسائل عن طريق الاختيار ، أو عند الرد على رسالة مشفرة. </string>
+  <string name="dialog_autocrypt_mutual_description_2">إذا قام كل من المرسل والمستلم بتمكين الوضع المتبادل ، فسيتم تمكين التشفير افتراضيًا. </string>
+  <string name="dialog_openkeychain_info_text">يتطلب K-9 Mail OpenKeychain للتشفير من طرف إلى طرف. </string>
+  <string name="account_settings_crypto_encrypt_subject">تشفير مواضيع الرسالة </string>
+  <string name="account_settings_crypto_encrypt_subject_subtitle">قد لا تكون مدعومة من قبل بعض المستلمين </string>
+  <string name="toast_account_not_found">خطأ داخلي: حساب غير صالح! </string>
+  <string name="toast_openpgp_provider_error">خطأ في الاتصال بـ %s!</string>
+  <string name="ac_transfer_setting_title">إرسال رسالة إعداد تشفير تلقائي </string>
+  <string name="ac_transfer_setting_summary">مشاركة الإعداد الشامل بأمان مع الأجهزة الأخرى </string>
+  <string name="ac_transfer_title">تشفير تلقائي لرسالة الإعداد </string>
+  <string name="ac_transfer_intro">تقوم رسالة إعداد Autocrypt بمشاركة الإعداد الشامل الخاص بك بأمان مع الأجهزة الأخرى. </string>
+  <string name="ac_transfer_button_send">إرسال رسالة الإعداد </string>
+  <string name="ac_transfer_will_be_sent">سيتم إرسال الرسالة إلى عنوانك: </string>
+  <string name="ac_transfer_generating">جاري إنشاء رسالة الإعداد … </string>
+  <string name="ac_transfer_finish">للإنهاء ، افتح الرسالة على جهازك الآخر وأدخل رمز الإعداد. </string>
+  <string name="ac_transfer_show_code">إظهار كود الإعداد </string>
+  <string name="ac_transfer_msg_subject">تشفير تلقائي لرسالة الإعداد</string>
+  <string name="ac_transfer_msg_body">تحتوي هذه الرسالة على جميع المعلومات اللازمة لنقل إعدادات التشفير التلقائي إلى جانب مفتاحك السري بأمان من جهازك الأصلي. لإعداد جهازك الجديد لـ Autocrypt ، يرجى اتباع الإرشادات التي يجب أن يقدمها جهازك الجديد.  يمكنك الاحتفاظ هذه الرسالة واستخدامها كنسخة احتياطية لمفتاحك السري. إذا كنت ترغب في القيام بذلك ، يجب عليك كتابة كلمة المرور وتخزينها بشكل آمن </string>
+  <string name="ac_transfer_error_send">حدث خطأ أثناء إرسال الرسالة. يرجى التحقق من اتصال الشبكة وتكوين خادم البريد الصادر. </string>
+  <!--permissions-->
+  <string name="permission_contacts_rationale_title">السماح بالوصول إلى جهات الاتصال </string>
+  <string name="permission_contacts_rationale_message">لتتمكن من تقديم اقتراحات جهات الاتصال وعرض أسماء جهات الاتصال والصور ، يحتاج التطبيق إلى الوصول إلى جهات الاتصال الخاصة بك. </string>
+  <string name="generic_loading_error">حدث خطأ أثناء تحميل البيانات </string>
+  <string name="push_notification_state_initializing">جار تهيئة… </string>
+  <string name="push_notification_state_listening">في انتظار رسائل البريد الإلكتروني الجديدة </string>
+  <string name="push_notification_state_wait_background_sync">السكون حتى يتم السماح بالمزامنة في الخلفية </string>
+  <string name="push_notification_state_wait_network">السكون حتى تتوفر الشبكة </string>
+  <string name="push_notification_info">انقر لمعرفة المزيد. </string>
+  <string name="push_info_title">دفع المعلومات </string>
+  <string name="push_info_notification_explanation_text">عند استخدام Push ، يحتفظ K-9 Mail بالاتصال بخادم البريد. يتطلب Android عرض إشعار مستمر عندما يكون التطبيق نشطًا في الخلفية. %s</string>
+  <string name="push_info_configure_notification_text">ومع ذلك ، يسمح لك Android أيضًا بإخفاء الإشعار. </string>
+  <string name="push_info_configure_notification_action">تكوين الإشعارات</string>
+  <string name="push_info_disable_push_text">إذا لم تكن بحاجة إلى إشعارات فورية حول الرسائل الجديدة ، فيجب عليك تعطيل ميزة Push and Use Polling. يتحقق الاقتراع من البريد الجديد على فترات منتظمة ولا يحتاج إلى الإشعارات. </string>
+  <string name="push_info_disable_push_action">تعطيل الدفع </string>
+  <!--Name of the swipe action to mark a message as read. Try to keep it short.-->
+  <string name="swipe_action_mark_as_read">علامة القراءة </string>
+  <!--Name of the swipe action to move a message. The ellipsis (…) indicates that there is another step (selecting a folder) before the action is performed. Try to keep it short.-->
+  <string name="swipe_action_move">يتحرك… </string>
+  <!--Name of setting to configure whether to show a "compose" floating action button on top of the message list-->
+  <string name="general_settings_show_compose_button_title">إظهار زر الإنشاء العائم </string>
+  <!--Displayed in the toolbar when there was an error loading the message list, e.g. because the folder no longer exists.-->
+  <string name="message_list_error_title">خطأ </string>
+  <!--Displayed instead of the message list when a folder couldn't be found, e.g. due to an outdated home screen shortcut.-->
+  <string name="message_list_error_folder_not_found">المجلد غير موجود</string>
+  <!--Title of the toolbar that is displayed when the message details bottom sheet has been expanded-->
+  <string name="message_details_toolbar_title">تفاصيل الرسالة </string>
+  <!--Displayed when an email is missing the 'Date' header field and no date can be displayed in the message details bottom sheet.-->
+  <string name="message_details_missing_date">رأس \"التاريخ\" مفقود </string>
+  <!--Title of the "Reply to" section in the message details bottom sheet. This should probably be the same as the string 'reply_to_label'.-->
+  <string name="message_details_replyto_section_title">الرد على </string>
+  <!--Title of the "Bcc" section in the message details bottom sheet. This should probably be the same as the string 'recipient_bcc'.-->
+  <string name="message_details_bcc_section_title">BCC</string>
+  <!--Displayed when loading the message details has failed-->
+  <string name="message_details_loading_error">حدث خطأ أثناء تحميل تفاصيل الرسالة. </string>
+  <!--Name of the action to add a person to contacts. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+  <string name="action_add_to_contacts">أضف إلى جهات الاتصال </string>
+  <!--Name of the action to compose a new message to a particular address. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+  <string name="action_compose_message_to">إنشاء رسالة إلى </string>
+  <!--Name of the action to copy an email address to the clipboard. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+  <string name="action_copy_email_address">انسخ عنوان البريد الإلكتروني </string>
+  <!--Name of the action to copy a name and email address to the clipboard. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+  <string name="action_copy_name_and_email_address">انسخ الاسم وعنوان البريد الإلكتروني </string>
+  <!--A user visible label for the name and email address copied to the clipboard-->
+  <string name="clipboard_label_name_and_email_address">الاسم وعنوان البريد الإلكتروني </string>
+  <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-be/strings.xml b/app/ui/legacy/src/main/res/values-be/strings.xml
index 8decfd14fb422c0615ae117e0267316542b9bbae..918729fd04b94aa00d0eb7528f9d94f4b0e98e59 100644
--- a/app/ui/legacy/src/main/res/values-be/strings.xml
+++ b/app/ui/legacy/src/main/res/values-be/strings.xml
@@ -329,7 +329,6 @@
     <string name="account_setup_incoming_client_certificate_label">Сертыфікат кліента</string>
     <string name="account_setup_incoming_pop_server_label">Сервер POP3</string>
     <string name="account_setup_incoming_imap_server_label">Сервер IMAP</string>
-    <string name="account_setup_incoming_webdav_server_label">Сервер Exchange</string>
     <string name="account_setup_incoming_port_label">Порт</string>
     <string name="account_setup_incoming_security_label">Бяспека</string>
     <string name="account_setup_incoming_auth_type_label">Аўтэнтыфікацыя</string>
@@ -355,9 +354,6 @@
     <string name="spam_folder_label">Каталог спаму</string>
     <string name="account_setup_incoming_subscribed_folders_only_label">Паказваць толькі падпісаныя каталогі</string>
     <string name="account_setup_auto_expand_folder">Аўтапераход у каталог</string>
-    <string name="account_setup_incoming_webdav_path_prefix_label">Шлях OWA</string>
-    <string name="account_setup_incoming_webdav_auth_path_label">Шлях аўтэнтыфікацыі</string>
-    <string name="account_setup_incoming_webdav_mailbox_path_label">Псеўданім скрыні</string>
     <string name="account_setup_outgoing_title">Налады сервера выходнай пошты</string>
     <string name="account_setup_outgoing_smtp_server_label">Сервер SMTP</string>
     <string name="account_setup_outgoing_port_label">Порт</string>
@@ -1109,4 +1105,5 @@
     <string name="clipboard_label_email_address">Адрас электроннай пошты</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
     <string name="clipboard_label_name_and_email_address">Імя і email адрас</string>
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
 </resources>
diff --git a/app/ui/legacy/src/main/res/values-bg/strings.xml b/app/ui/legacy/src/main/res/values-bg/strings.xml
index 5983b64a036d35d390dbcc5086c26956045d5d04..8e6e6939f26145d0943ce2bc0803faf275eae2bb 100644
--- a/app/ui/legacy/src/main/res/values-bg/strings.xml
+++ b/app/ui/legacy/src/main/res/values-bg/strings.xml
@@ -421,7 +421,7 @@
     <string name="account_settings_crypto_key">Настройване на ключа за криптиране от край-докрай</string>
     <string name="account_settings_crypto_summary_off">Няма избрано OpenPGP приложение</string>
     <string name="account_settings_crypto_summary_on">Свързан с %s</string>
-    <string name="account_settings_crypto_summary_config">Конфигуриране ...</string>
+    <string name="account_settings_crypto_summary_config">Конфигуриране …</string>
     <string name="account_settings_crypto_encrypt_all_drafts">Съхранявайте всички чернови в криптиран вид</string>
     <string name="account_settings_crypto_encrypt_all_drafts_on">Всички чернови ще се съхраняват криптирани</string>
     <string name="account_settings_crypto_encrypt_all_drafts_off">Криптира чернови само ако е криптирането е активирано</string>
@@ -1002,4 +1002,6 @@
     <!--A user visible label for the email address copied to the clipboard-->
     <string name="clipboard_label_email_address">Имейл адрес</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
-</resources>
\ No newline at end of file
+    <!--A user visible label for the name and email address copied to the clipboard-->
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-br/strings.xml b/app/ui/legacy/src/main/res/values-br/strings.xml
index 6b90d03085c2d4077ed9486eb7e6398292b7bc52..f55cd2e10eca3f1516e16d716ecd673a4687fa6d 100644
--- a/app/ui/legacy/src/main/res/values-br/strings.xml
+++ b/app/ui/legacy/src/main/res/values-br/strings.xml
@@ -402,7 +402,7 @@
     <string name="account_settings_crypto_key">Kefluniañ an alc\'hwez penn-ouzh-penn</string>
     <string name="account_settings_crypto_summary_off">Arload OpenPGP ebet kefluniet</string>
     <string name="account_settings_crypto_summary_on">Kennasket ouzh %s</string>
-    <string name="account_settings_crypto_summary_config">O kefluniañ...</string>
+    <string name="account_settings_crypto_summary_config">O kefluniañ…</string>
     <string name="account_settings_crypto_encrypt_all_drafts">Kadaviñ an holl vrouilhedoù enrineget</string>
     <string name="account_settings_crypto_encrypt_all_drafts_on">An holl vrouilhedoù a vo kadavet enrineget</string>
     <string name="account_settings_crypto_encrypt_all_drafts_off">Enrinegañ ar brouilhedoù m\'eo gweredekaet an enrinegañ nemetken</string>
@@ -535,7 +535,7 @@
     <string name="sort_unread_last">Kemennadennoù lennet da gentañ</string>
     <string name="sort_attach_first">Kemennadennoù gant stagadennoù da gentañ</string>
     <string name="sort_unattached_first">Kemennadennoù hep stagadenn da gentañ</string>
-    <string name="sort_by">Urzhiañ dre...</string>
+    <string name="sort_by">Urzhiañ dre…</string>
     <string name="sort_by_date">Deiziad</string>
     <string name="sort_by_arrival">Degouezh</string>
     <string name="sort_by_subject">Danvez</string>
@@ -663,7 +663,7 @@
     <string name="settings_list_miscellaneous_category">Liesseurt</string>
     <string name="settings_export_button">Ezporzhiañ</string>
     <string name="settings_export_share_button">Rannañ</string>
-    <string name="settings_export_progress_text">Oc’h ezporzhiañ an arventennoù...</string>
+    <string name="settings_export_progress_text">Oc’h ezporzhiañ an arventennoù…</string>
     <string name="settings_export_success_generic">Arventennoù ezporzhiet gant berzh</string>
     <string name="settings_export_failure">C’hwitadenn war ezporzhiañ an arventennoù</string>
     <string name="settings_import_title">Enporzhiañ an arventennoù</string>
@@ -673,8 +673,8 @@
     <!--Displayed after importing accounts when some accounts require entering a password and some to use the OAuth authorization flow-->
     <!--Content description for the icon that is displayed next to an imported account that requires sign-in-->
     <string name="settings_import">Enporzhiañ an arventennoù</string>
-    <string name="settings_importing">Oc’h enporzhiañ an arventennoù...</string>
-    <string name="unread_widget_select_account">Diskouez an niver a bosteloù anlennet evit...</string>
+    <string name="settings_importing">Oc’h enporzhiañ an arventennoù…</string>
+    <string name="unread_widget_select_account">Diskouez an niver a bosteloù anlennet evit…</string>
     <string name="unread_widget_account_title">Kont</string>
     <string name="unread_widget_account_summary">Ar gont implijet evit diskouez an niver a gemennadennoù anlennet</string>
     <string name="unread_widget_unified_inbox_account_summary">Boest degemer unanet</string>
@@ -738,7 +738,7 @@
     <string name="global_settings_threaded_view_label">Gwell e neudennoù</string>
     <string name="global_settings_threaded_view_summary">Strollañ ar c’hemennadennoù dre gaozeadenn</string>
     <string name="upgrade_databases_title">Oc’h hizivaat ar stlennvon</string>
-    <string name="upgrade_databases_unspecified">Oc’h hizivaat ar stlennvonioù...</string>
+    <string name="upgrade_databases_unspecified">Oc’h hizivaat ar stlennvonioù…</string>
     <string name="upgrade_database_format">Oc’h hizivaat stlennvon ar gont \"<xliff:g id="account">%s</xliff:g>\"</string>
     <string name="global_settings_splitview_mode_label">Diskouez ar skramm disrannet</string>
     <string name="global_settings_splitview_always">Atav</string>
@@ -752,10 +752,10 @@
     <string name="global_settings_colorize_missing_contact_pictures_summary">Livañ skeudennoù an darempredoù a vank</string>
     <string name="global_settings_messageview_visible_refile_actions_title">Gweredoù kemennadennoù gwelus</string>
     <string name="global_settings_messageview_visible_refile_actions_summary">Diskouez ar gweredoù diuzet el lañser gwel kemennadenn</string>
-    <string name="loading_attachment">O kargañ ar genstagadenn...</string>
+    <string name="loading_attachment">O kargañ ar genstagadenn…</string>
     <string name="fetching_attachment_dialog_title_send">O kas ar gemennadenn</string>
     <string name="fetching_attachment_dialog_title_save">Oc’h enrollañ ar brouilhed</string>
-    <string name="fetching_attachment_dialog_message">O kerc’hat ar genstagadenn...</string>
+    <string name="fetching_attachment_dialog_message">O kerc’hat ar genstagadenn…</string>
     <string name="auth_external_error">N’haller ket dilesa. N’eo ket brudet ar varregezh SASL EXTERNAL gant an dafariad. Gallout a ra bezañ abalamour d’ur gudenn gant testeni an arval (diamzeret, aotrouniezh testeni dianav) pe ur gudenn kefluniadur all. </string>
     <!--=== Client certificates specific ==================================================================-->
     <string name="account_setup_basics_client_certificate">Arverañ testeni an arval</string>
@@ -840,7 +840,7 @@
     <string name="locked_attach_unlock">Dibrennañ</string>
     <string name="locked_attach_unencrypted">N’eo ket enrineget al lodenn-mañ ha marteze n’eo ket diogel.</string>
     <string name="locked_attach_title">N’eo ket gwarezet ar genstagadenn</string>
-    <string name="message_progress_text">O kargañ...</string>
+    <string name="message_progress_text">O kargañ…</string>
     <string name="messageview_decrypt_cancelled">Nullet eo bet an ezrinegañ.</string>
     <string name="messageview_decrypt_retry">Adklask</string>
     <string name="messageview_decrypt_incomplete">Ar c’hemennadennoù enrineget a rank bezañ pellgarget evit o ezrinegañ.</string>
@@ -856,7 +856,7 @@
     <string name="crypto_no_provider_message">Enrineget eo bet ar postel-mañ gant OpenPGP.\nEvit gallout e lenn e rankit staliañ ha kefluniañ un arload OpenPGP keverlec’h.</string>
     <string name="crypto_no_provider_button">Mont d\'an arventennoù</string>
     <string name="mail_list_widget_text">Roll kemennadennoù Mail</string>
-    <string name="mail_list_widget_loading">O kargañ kemennadennoù...</string>
+    <string name="mail_list_widget_loading">O kargañ kemennadennoù…</string>
     <!--Displayed in the the message list widget when the app hasn't had a chance to send content to it yet-->
     <string name="message_list_widget_initializing">O kargañ…</string>
     <!--Might be displayed in the message list widget when the list is scrolled and new data can't be fetched fast enough-->
@@ -892,7 +892,7 @@
     <string name="ac_transfer_intro">Ur gemennadenn kefluniañ Autocrypt a rann ho kefluniadur penn-ouzh-penn gant trevnadoù all en un doare diogel.</string>
     <string name="ac_transfer_button_send">Kas ar gemennadenn gefluniañ</string>
     <string name="ac_transfer_will_be_sent">Kaset e vo ar gemennadenn d\'ho chomlec\'h:</string>
-    <string name="ac_transfer_generating">O genel ar c\'hemennadennoù kefluniañ...</string>
+    <string name="ac_transfer_generating">O genel ar c\'hemennadennoù kefluniañ…</string>
     <string name="ac_transfer_sending_to">O kas ar gemennadenn da:</string>
     <string name="ac_transfer_finish">Evit echuiñ, digorit ar gemennadenn war ho trevnad all hag enankit ar boneg kefluniañ.</string>
     <string name="ac_transfer_show_code">Diskouez ar boneg kefluniañ</string>
@@ -950,4 +950,5 @@ Gallout a rit mirout ar gemennadenn-mañ hag implij anezhi evel un enrolladenn e
     <!--A user visible label for the email address copied to the clipboard-->
     <string name="clipboard_label_email_address">Chomlec’h postel</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
-</resources>
\ No newline at end of file
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-ca/strings.xml b/app/ui/legacy/src/main/res/values-ca/strings.xml
index 9d462ae9cad59bf4a564df536c6e051e5c6fa58a..3f1c3fd0cf853d76e30e4753ca0326c0fb840f23 100644
--- a/app/ui/legacy/src/main/res/values-ca/strings.xml
+++ b/app/ui/legacy/src/main/res/values-ca/strings.xml
@@ -464,7 +464,7 @@
     <string name="account_settings_crypto_key">Configureu la clau d\'extrem a extrem</string>
     <string name="account_settings_crypto_summary_off">No hi ha cap aplicació d\'OpenPGP configurada.</string>
     <string name="account_settings_crypto_summary_on">Connectat a %s</string>
-    <string name="account_settings_crypto_summary_config">Es configura...</string>
+    <string name="account_settings_crypto_summary_config">Es configura…</string>
     <string name="account_settings_crypto_encrypt_all_drafts">Desa tots els esborranys encriptats</string>
     <string name="account_settings_crypto_encrypt_all_drafts_on">Tots els esborranys es desaran encriptats</string>
     <string name="account_settings_crypto_encrypt_all_drafts_off">Encripta els esborranys només si l\'encriptació està habilitada</string>
@@ -472,7 +472,7 @@
     <string name="account_settings_color_label">Color del compte</string>
     <string name="account_settings_color_summary">Tria el color del compte utilitzat a la llista de carpetes i de comptes</string>
     <string name="account_settings_mail_display_count_label">Mida de la carpeta local</string>
-    <string name="account_settings_autodownload_message_size_label">Recupera missatges fins a...</string>
+    <string name="account_settings_autodownload_message_size_label">Recupera missatges fins a…</string>
     <string name="account_settings_autodownload_message_size_1">1 KiB</string>
     <string name="account_settings_autodownload_message_size_2">2 KiB</string>
     <string name="account_settings_autodownload_message_size_4">4 KiB</string>
@@ -637,7 +637,7 @@
     <string name="account_setup_failed_dlg_invalid_certificate_accept">Accepta la clau</string>
     <string name="account_setup_failed_dlg_invalid_certificate_reject">Rebutja la clau</string>
     <string name="folder_list_filter_hint">El nom de carpeta conté</string>
-    <string name="folder_list_display_mode_label">Carpetes...</string>
+    <string name="folder_list_display_mode_label">Carpetes…</string>
     <string name="folder_list_display_mode_all">Mostra totes les carpetes</string>
     <string name="folder_list_display_mode_first_class">Mostra només carpetes de 1a classe</string>
     <string name="folder_list_display_mode_first_and_second_class">Mostra carpetes de 1a i 2a classe</string>
@@ -757,7 +757,7 @@
     <string name="settings_export_title">Configuració de l\'exportació</string>
     <string name="settings_export_button">Exporta</string>
     <string name="settings_export_share_button">Comparteix</string>
-    <string name="settings_export_progress_text">S\'està exportant la configuració...</string>
+    <string name="settings_export_progress_text">S\'està exportant la configuració…</string>
     <string name="settings_export_success_generic">La configuració s\'ha exportat correctament.</string>
     <string name="settings_export_failure">Ha fallat exportar la configuració.</string>
     <string name="settings_import_title">Importa la configuració</string>
@@ -781,7 +781,7 @@
     <string name="settings_import_status_error">Fallada d\'importació</string>
     <string name="settings_import_later_button">Més tard</string>
     <string name="settings_import">Importa la configuració</string>
-    <string name="settings_importing">Important la configuració...</string>
+    <string name="settings_importing">Important la configuració…</string>
     <plurals name="settings_import_password_prompt">
         <item quantity="one">Per poder usar el compte <xliff:g id="account">%s</xliff:g> heu de proporcionar la contrasenya del servidor. </item>
         <item quantity="other">Per poder fer servir el compte <xliff:g id="account">%s</xliff:g> heu de proporcionar les contrasenyes del servidor. </item>
@@ -790,7 +790,7 @@
     <string name="settings_import_outgoing_server_password_hint">Contrasenya del servidor de sortida</string>
     <string name="settings_import_use_same_password_for_outgoing_server">Fes servir la mateixa contrasenya per al servidor de sortida.</string>
     <string name="server_name_format">Nom del servidor: <xliff:g id="hostname">%s</xliff:g></string>
-    <string name="unread_widget_select_account">Mostra el recompte de no llegits per a...</string>
+    <string name="unread_widget_select_account">Mostra el recompte de no llegits per a…</string>
     <string name="unread_widget_account_title">Compte</string>
     <string name="unread_widget_account_summary">El compte per al qual s\'ha de mostrar el nombre de missatges no llegits.</string>
     <string name="unread_widget_unified_inbox_account_summary">Bústia unificada</string>
@@ -850,7 +850,7 @@
     <string name="global_settings_threaded_view_label">Vista de fil de discussió</string>
     <string name="global_settings_threaded_view_summary">Recull els missatges del mateix fil de discussió</string>
     <string name="upgrade_databases_title">Actualització de les bases de dades</string>
-    <string name="upgrade_databases_unspecified">Actualitzant les bases de dades...</string>
+    <string name="upgrade_databases_unspecified">Actualitzant les bases de dades…</string>
     <string name="upgrade_database_format">Actualitzant la base de dades del compte \"<xliff:g id="account">%s</xliff:g>\"</string>
     <string name="global_settings_splitview_mode_label">Mostra amb pantalla dividida</string>
     <string name="global_settings_splitview_always">Sempre</string>
@@ -955,7 +955,7 @@
     <string name="locked_attach_unlock">Desbloqueja</string>
     <string name="locked_attach_unencrypted">Aquesta part no estava encriptada i pot no ser segura.</string>
     <string name="locked_attach_title">Adjunt no protegit</string>
-    <string name="message_progress_text">Carregant...</string>
+    <string name="message_progress_text">Carregant…</string>
     <string name="messageview_decrypt_cancelled">S\'ha cancel·lat la desencriptació.</string>
     <string name="messageview_decrypt_retry">Torna-hi</string>
     <string name="messageview_decrypt_incomplete">Cal baixar el missatge encriptat per desencriptar-lo.</string>
@@ -971,7 +971,7 @@
     <string name="crypto_no_provider_message">Aquest missatge ha estat encriptat amb OpenPGP.\nPer llegir-lo, us caldrà instal·lar i configurar una aplicació d\'OpenPGP compatible.</string>
     <string name="crypto_no_provider_button">Ves a la configuració</string>
     <string name="mail_list_widget_text">Llista de missatges del Mail</string>
-    <string name="mail_list_widget_loading">Carregant missatges...</string>
+    <string name="mail_list_widget_loading">Carregant missatges…</string>
     <!--Displayed in the the message list widget when the app hasn't had a chance to send content to it yet-->
     <string name="message_list_widget_initializing">S\'està carregant…</string>
     <!--Might be displayed in the message list widget when the list is scrolled and new data can't be fetched fast enough-->
@@ -1007,7 +1007,7 @@
     <string name="ac_transfer_intro">Un missatge de configuració d\'autoencriptació comparteix amb seguretat la configuració d\'extrem a extrem amb altres dispositius.</string>
     <string name="ac_transfer_button_send">Envia un missatge de configuració</string>
     <string name="ac_transfer_will_be_sent">El missatge s\'enviarà a la vostra adreça:</string>
-    <string name="ac_transfer_generating">Es genera el missatge de configuració...</string>
+    <string name="ac_transfer_generating">Es genera el missatge de configuració…</string>
     <string name="ac_transfer_sending_to">S\'envia el missatge a:</string>
     <string name="ac_transfer_finish">Per acabar, obriu el missatge a l\'altre dispositiu i introduïu-hi el codi de configuració.</string>
     <string name="ac_transfer_show_code">Mostra el codi de configuració</string>
@@ -1025,7 +1025,7 @@ Podeu guardar aquest missatge i usar-lo com a còpia de seguretat per a la vostr
     <string name="permission_contacts_rationale_title">Permet l\'accés als contactes</string>
     <string name="permission_contacts_rationale_message">Per poder proporcionar suggeriments de contactes i mostrar-ne els noms i fotografies, l\'aplicació necessita accés als vostres contactes.</string>
     <string name="generic_loading_error">S\'ha produït un error en carregar les dades</string>
-    <string name="push_notification_state_initializing">S\'inicia...</string>
+    <string name="push_notification_state_initializing">S\'inicia…</string>
     <string name="push_notification_state_listening">S\'està esperant nous correus electrònics</string>
     <string name="push_notification_state_wait_background_sync">Inactiu fins que es permeti la sincronització</string>
     <string name="push_notification_state_wait_network">Inactiu fins que la xarxa estigui disponible</string>
@@ -1093,4 +1093,5 @@ Podeu guardar aquest missatge i usar-lo com a còpia de seguretat per a la vostr
     <string name="clipboard_label_email_address">Envia un correu electrònic a aquesta adreça</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
     <string name="clipboard_label_name_and_email_address">Nom i adreça de correu</string>
-</resources>
\ No newline at end of file
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-cs/strings.xml b/app/ui/legacy/src/main/res/values-cs/strings.xml
index 66608ca89d45fc500d8474e9f89bfe98bfb23c43..2becf5d8c383e0c1cd554d860791f5c4a4e196a0 100644
--- a/app/ui/legacy/src/main/res/values-cs/strings.xml
+++ b/app/ui/legacy/src/main/res/values-cs/strings.xml
@@ -1107,4 +1107,5 @@ Tuto zprávu si můžete ponechat a použít jí jako zálohu svého tajného kl
     <string name="clipboard_label_email_address">E-mailová adresa</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
     <string name="clipboard_label_name_and_email_address">Jméno a adresa</string>
-</resources>
\ No newline at end of file
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-cy/strings.xml b/app/ui/legacy/src/main/res/values-cy/strings.xml
index 0978361f4fec3b953bcb9eb06c847b34dd8f6384..dae954dee01012d721babe5d30c569363926168e 100644
--- a/app/ui/legacy/src/main/res/values-cy/strings.xml
+++ b/app/ui/legacy/src/main/res/values-cy/strings.xml
@@ -50,7 +50,7 @@
     <string name="compose_title_forward_as_attachment">Anfon ymlaen fel atodiad</string>
     <string name="choose_account_title">Dewis cyfrif</string>
     <string name="choose_folder_title">Dewis ffolder</string>
-    <string name="choose_folder_move_title">Symud i...</string>
+    <string name="choose_folder_move_title">Symud i…</string>
     <string name="choose_folder_copy_title">Copïo i…</string>
     <string name="actionbar_selected"><xliff:g id="selection_count">%d</xliff:g> wedi\'i dewis</string>
     <string name="next_action">Nesaf</string>
@@ -1080,4 +1080,5 @@ Mae\'n bosib i ti gadw\'r neges hon a\'i ddefnyddio wrth gefn fel dy allwedd gyf
     <!--A user visible label for the email address copied to the clipboard-->
     <string name="clipboard_label_email_address">Cyfeiriad e-bost</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
-</resources>
\ No newline at end of file
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-da/strings.xml b/app/ui/legacy/src/main/res/values-da/strings.xml
index 00c13a42117e2ff9a604c65db19832b4245f2ed3..99ec98bf8dfbfdd88ab9b522b0908d9af3efc06c 100644
--- a/app/ui/legacy/src/main/res/values-da/strings.xml
+++ b/app/ui/legacy/src/main/res/values-da/strings.xml
@@ -50,8 +50,8 @@
     <string name="compose_title_forward_as_attachment">Videresend som vedhæftet</string>
     <string name="choose_account_title">Vælg konto</string>
     <string name="choose_folder_title">Vælg mappe</string>
-    <string name="choose_folder_move_title">Flyt til...</string>
-    <string name="choose_folder_copy_title">Kopier til...</string>
+    <string name="choose_folder_move_title">Flyt til…</string>
+    <string name="choose_folder_copy_title">Kopier til…</string>
     <string name="actionbar_selected"><xliff:g id="selection_count">%d</xliff:g> valgt</string>
     <string name="next_action">Næste</string>
     <!--Used to confirm acceptance of dialog boxes, warnings, errors, etc.-->
@@ -997,6 +997,16 @@ For at indstille den nye enhed til Autocrypt, følg instruktionerne der vises p
 
 Beskeden kan beholdes og bruges som sikkerhedskopi til den hemmelige nøgle. Hvis dette gøres skal adgangskoden gemmes sikkert.
 </string>
+    <!--Button text of the "snack bar" that is displayed when the app was updated.-->
+    <string name="changelog_snackbar_button_text">Vis</string>
+    <string name="unsubscribe_action">Afmeld</string>
+    <!--Text of the button that is displayed below the message header when the message body references one or more remote images-->
+    <string name="message_view_show_remote_images_action">Vis eksterne billeder</string>
+    <!--Title of the setting to specify the density of the message list-->
+    <string name="general_settings_ui_density_compact">Kompakt</string>
+    <string name="general_settings_ui_density_relaxed">Afslappet</string>
+    <string name="account_settings_notification_channels_label">Notifikation kategorier</string>
+    <string name="font_size_message_view_recipients">Modtagere</string>
     <string name="ac_transfer_error_send">Fejl opstod under sending af besked. Kontrollere netværk forbindelse og udgående server indstilling.</string>
     <string name="switch_on">Til</string>
     <string name="switch_off">Fra</string>
@@ -1035,7 +1045,7 @@ Beskeden kan beholdes og bruges som sikkerhedskopi til den hemmelige nøgle. Hvi
     <!--Name of the swipe action to move a message to the Spam folder. Try to keep it short.-->
     <string name="swipe_action_spam">Spam</string>
     <!--Name of the swipe action to move a message. The ellipsis (…) indicates that there is another step (selecting a folder) before the action is performed. Try to keep it short.-->
-    <string name="swipe_action_move">Flyt...</string>
+    <string name="swipe_action_move">Flyt…</string>
     <!--Name of setting to configure whether to show a "compose" floating action button on top of the message list-->
     <!--Displayed in the toolbar when there was an error loading the message list, e.g. because the folder no longer exists.-->
     <string name="message_list_error_title">Fejl</string>
@@ -1068,4 +1078,7 @@ Beskeden kan beholdes og bruges som sikkerhedskopi til den hemmelige nøgle. Hvi
     <string name="clipboard_label_email_address">Mail addresse</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
     <string name="clipboard_label_name_and_email_address">Navn og email-adresse</string>
-</resources>
\ No newline at end of file
+    <!--Name of the action to compose a new message to a particular address. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+    <string name="action_compose_message_to">Skriv meddelelse til</string>
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-de/strings.xml b/app/ui/legacy/src/main/res/values-de/strings.xml
index c43b0125970a401d04d15688f552c8672bd40362..b19c8e439a16471ba0a1c8d004e7db7a43d91577 100644
--- a/app/ui/legacy/src/main/res/values-de/strings.xml
+++ b/app/ui/legacy/src/main/res/values-de/strings.xml
@@ -280,7 +280,6 @@
     <string name="account_setup_incoming_client_certificate_label">Client-Zertifikat</string>
     <string name="account_setup_incoming_pop_server_label">POP3-Server</string>
     <string name="account_setup_incoming_imap_server_label">IMAP-Server</string>
-    <string name="account_setup_incoming_webdav_server_label">WebDAV(Exchange)-Server</string>
     <string name="account_setup_incoming_port_label">Port</string>
     <string name="account_setup_incoming_security_label">Sicherheitstyp</string>
     <string name="account_setup_incoming_auth_type_label">Authentifizierungstyp</string>
@@ -306,9 +305,6 @@
     <string name="spam_folder_label">Ordner für Spam</string>
     <string name="account_setup_incoming_subscribed_folders_only_label">Nur ausgewählte Ordner anzeigen</string>
     <string name="account_setup_auto_expand_folder">Startordner</string>
-    <string name="account_setup_incoming_webdav_path_prefix_label">WebDAV-(Exchange-)Pfad</string>
-    <string name="account_setup_incoming_webdav_auth_path_label">Authentifizierungspfad</string>
-    <string name="account_setup_incoming_webdav_mailbox_path_label">Mailbox-Pfad</string>
     <string name="account_setup_outgoing_title">Einstellungen für Postausgangsserver</string>
     <string name="account_setup_outgoing_smtp_server_label">SMTP-Server</string>
     <string name="account_setup_outgoing_port_label">Port</string>
@@ -1077,4 +1073,5 @@
     <string name="account_setup_incoming_send_client_id">Klienten-ID senden</string>
     <string name="font_size_message_view_account">Kontoname</string>
     <string name="action_compose_message_to">Nachricht verfassen an</string>
-</resources>
\ No newline at end of file
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-el/strings.xml b/app/ui/legacy/src/main/res/values-el/strings.xml
index a02cb975120ab826b18fffd20e128b469b9a0f1e..5d41fbcc4d01796524f880bd4ad7c2d55c442976 100644
--- a/app/ui/legacy/src/main/res/values-el/strings.xml
+++ b/app/ui/legacy/src/main/res/values-el/strings.xml
@@ -448,7 +448,7 @@
     <string name="account_settings_crypto_key">Ρύθμιση διατερματικού κλειδιού</string>
     <string name="account_settings_crypto_summary_off">Δεν έχει ρυθμιστεί εφαρμογή OpenPGP</string>
     <string name="account_settings_crypto_summary_on">Συνδεδεμένος σε %s</string>
-    <string name="account_settings_crypto_summary_config">Διαμόρφωση...</string>
+    <string name="account_settings_crypto_summary_config">Διαμόρφωση…</string>
     <string name="account_settings_crypto_encrypt_all_drafts">Αποθήκευση όλων των πρόχειρων ως κρυπτογραφημένα</string>
     <string name="account_settings_crypto_encrypt_all_drafts_on">Όλα τα πρόχειρα θα αποθηκεύονται κρυπτογραφημένα</string>
     <string name="account_settings_crypto_encrypt_all_drafts_off">Κρυπτογράφηση πρόχειρων μόνο εάν είναι ενεργοποιημένη η λειτουργία κρυπτογράφησης</string>
@@ -954,7 +954,7 @@
     <string name="crypto_no_provider_message">Αυτό το μήνυμα έχει κρυπτογραφηθεί με το OpenPGP.\nΓια να το διαβάσετε, πρέπει να εγκαταστήσετε και να ρυθμίσετε τις παραμέτρους μιας συμβατής εφαρμογής OpenPGP.</string>
     <string name="crypto_no_provider_button">Μετάβαση στις Ρυθμίσεις</string>
     <string name="mail_list_widget_text">Λίστα Μηνυμάτων του Mail</string>
-    <string name="mail_list_widget_loading">Φόρτωση μηνυμάτων...</string>
+    <string name="mail_list_widget_loading">Φόρτωση μηνυμάτων…</string>
     <!--Displayed in the the message list widget when the app hasn't had a chance to send content to it yet-->
     <string name="message_list_widget_initializing">Φόρτωση…</string>
     <!--Might be displayed in the message list widget when the list is scrolled and new data can't be fetched fast enough-->
@@ -990,17 +990,45 @@
     <string name="ac_transfer_intro">Ένα Μήνυμα Ρύθμισης Autocrypt μοιράζεται, με ασφάλεια, τη διατερματική σας ρύθμιση με άλλες συσκευές.</string>
     <string name="ac_transfer_button_send">Αποστολή Μηνύματος Ρύθμισης</string>
     <string name="ac_transfer_will_be_sent">Το μήνυμα θα σταλεί στη διεύθυνσή σας:</string>
-    <string name="ac_transfer_generating">Δημιουργία μηνύματος ρύθμισης...</string>
+    <string name="ac_transfer_generating">Δημιουργία μηνύματος ρύθμισης…</string>
     <string name="ac_transfer_sending_to">Αποστολή μηνύματος σε:</string>
     <string name="ac_transfer_finish">Για να τελειώσετε, ανοίξτε το μήνυμα στην άλλη συσκευή σας και καταχωρίστε τον κωδικό ρύθμισης.</string>
     <string name="ac_transfer_show_code">Εμφάνιση Κωδικού Ρύθμισης</string>
     <string name="ac_transfer_msg_subject">Μήνυμα Ρύθμισης Autocrypt</string>
     <string name="ac_transfer_msg_body">Αυτό το μήνυμα περιέχει όσες πληροφορίες χρειάζεστε για την ασφαλή μεταφορά των ρυθμίσεων Autocrypt μαζί με το μυστικό σας κλειδί από την αρχική συσκευή. 
 
-Για να ρυθμίσετε τη νέα σας συσκευή για Autocrypt, παρακαλώ ακολουθήστε τις οδηγίες που θα πρέπει να παρουσιάζονται από τη νέα σας συσκευή. 
+Για να ρυθμίσετε τη νέα σας συσκευή για Autocrypt, παρακαλώ ακολουθήστε τις οδηγίες που θα πρέπει να παρουσιάζονται από τη νέα σας συσκευή.
 
 Μπορείτε να κρατήσετε αυτό το μήνυμα και να το χρησιμοποιήσετε ως εφεδρικό για το μυστικό σας κλειδί. Εάν αυτό επιθυμείτε, θα πρέπει να σημειώσετε τον κωδικό και να τον αποθηκεύσετε σε ασφαλές σημείο.
 </string>
+    <!--Button text of the "snack bar" that is displayed when the app was updated.-->
+    <string name="changelog_snackbar_button_text">Προβολή</string>
+    <!--Displayed in the message view screen in front of the recipient list. For most languages this should end with a space.-->
+    <string name="message_view_recipient_prefix">σε</string>
+    <!--Displayed in the message view screen in front of the number of additional recipients (the ones that are not displayed).-->
+    <string name="message_view_additional_recipient_prefix">+</string>
+    <!--Displayed in the message view screen if the message was addressed to the user. Make sure this works with 'message_view_recipient_prefix'. In English it's "to me".-->
+    <!--Text of the button that is displayed below the message header when the message body references one or more remote images-->
+    <string name="message_view_show_remote_images_action">Εμφάνιση αποκρυμμένων εικόνων</string>
+    <!--Title of the screen to configure swipe actions-->
+    <string name="general_settings_swipe_actions_title">Ενέργειες ολίσθησης</string>
+    <!--Name of the setting to configure the right swipe action-->
+    <string name="general_settings_right_swipe_title">Ολίσθηση δεξιά</string>
+    <!--Name of the setting to configure the left swipe action-->
+    <string name="general_settings_left_swipe_title">Ολίσθηση αριστερά</string>
+    <!--Name of the swipe action to select/deselect a message-->
+    <string name="general_settings_swipe_action_toggle_selection">Πολλαπλή επιλογή</string>
+    <!--Name of the swipe action to mark as message as read/unread-->
+    <string name="general_settings_swipe_action_toggle_read">Επισήμανση ως Αναγνωσμένο/Μη αναγν.</string>
+    <!--Name of the swipe action to add/remove a star-->
+    <string name="general_settings_swipe_action_toggle_star">Προσθήκη/Αφαίρεση αστεριού</string>
+    <!--Title of the setting to specify the density of the message list-->
+    <string name="general_settings_message_list_density_title">Κενό μεταξύ στοιχείων</string>
+    <string name="account_settings_notification_channels_label">Κατηγορίες ειδοποιήσεων</string>
+    <string name="account_settings_open_notification_settings_messages_summary">Ρύθμιση ειδοποιήσεων για νέα μηνύματα</string>
+    <string name="account_settings_open_notification_settings_miscellaneous_summary">Ρύθμιση ειδοποιήσεων σφαλμάτων και κατάστασης</string>
+    <string name="show_starred_count_title">Εμφάνιση πλήθους επιλεγμένων</string>
+    <string name="font_size_message_view_recipients">Αποδέκτες</string>
     <string name="ac_transfer_error_send">Προέκυψε ένα σφάλμα κατά την αποστολή του μηνύματος. Παρακαλώ ελέγξτε τη συνδεσιμότητα του δικτύου σας και τη διαμόρφωση του εξερχόμενου εξυπηρετητή.</string>
     <string name="switch_on">Ενεργό</string>
     <string name="switch_off">Ανενεργό</string>
@@ -1063,4 +1091,31 @@
     <!--A user visible label for the email address copied to the clipboard-->
     <string name="clipboard_label_email_address">Διεύθυνση ηλ. ταχυδρομείου </string>
     <!--A user visible label for the name and email address copied to the clipboard-->
-</resources>
\ No newline at end of file
+    <!--Name of the swipe action to mark a message as read. Try to keep it short.-->
+    <string name="swipe_action_mark_as_read">Επισήμανση ως αναγνωσμένο</string>
+    <!--Name of the swipe action to move a message. The ellipsis (…) indicates that there is another step (selecting a folder) before the action is performed. Try to keep it short.-->
+    <string name="swipe_action_move">Μετακίνηση…</string>
+    <!--Name of setting to configure whether to show a "compose" floating action button on top of the message list-->
+    <string name="general_settings_show_compose_button_title">Εμφάνιση εικονιδίου σύνθεσης</string>
+    <!--Displayed in the toolbar when there was an error loading the message list, e.g. because the folder no longer exists.-->
+    <string name="message_list_error_title">Σφάλμα</string>
+    <!--Displayed instead of the message list when a folder couldn't be found, e.g. due to an outdated home screen shortcut.-->
+    <string name="message_list_error_folder_not_found">Ο φάκελος δεν βρέθηκε</string>
+    <!--Title of the toolbar that is displayed when the message details bottom sheet has been expanded-->
+    <string name="message_details_toolbar_title">Λεπτομέρειες μηνύματος</string>
+    <!--Displayed when an email is missing the 'Date' header field and no date can be displayed in the message details bottom sheet.-->
+    <string name="message_details_missing_date">Λείπει η κεφαλίδα \'Ημερομηνία\'</string>
+    <!--Displayed when loading the message details has failed-->
+    <string name="message_details_loading_error">Προέκυψε σφάλμα κατά τη φόρτωση των λεπτομερειών του μηνύματος.</string>
+    <!--Name of the action to add a person to contacts. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+    <string name="action_add_to_contacts">Προσθήκη στις Επαφές</string>
+    <!--Name of the action to compose a new message to a particular address. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+    <string name="action_compose_message_to">Σύνθεση μηνύματος σε</string>
+    <!--Name of the action to copy an email address to the clipboard. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+    <string name="action_copy_email_address">Αντιγραφή διεύθυνσης ηλ. ταχυδρομείου</string>
+    <!--Name of the action to copy a name and email address to the clipboard. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+    <string name="action_copy_name_and_email_address">\'Αντιγραφή ονόματος και διεύθυνσης ηλ. ταχυδρομείου</string>
+    <!--A user visible label for the name and email address copied to the clipboard-->
+    <string name="clipboard_label_name_and_email_address">\'Ονομα και διεύθυνση ηλ. ταχυδρομείου</string>
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-eo/strings.xml b/app/ui/legacy/src/main/res/values-eo/strings.xml
index 2726ad5d625dcadb5de4c9f35e6ffa004727e44f..b0d584e0f47023f5dc6ab99d0cc2b6109f83913c 100644
--- a/app/ui/legacy/src/main/res/values-eo/strings.xml
+++ b/app/ui/legacy/src/main/res/values-eo/strings.xml
@@ -1023,4 +1023,5 @@ Vi povas konservi tiun ĉi mesaĝon kaj uzi ĝin kiel sekurkopion de via privata
     <!--A user visible label for the email address copied to the clipboard-->
     <string name="clipboard_label_email_address">Retpoŝta adreso</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
-</resources>
\ No newline at end of file
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-es/strings.xml b/app/ui/legacy/src/main/res/values-es/strings.xml
index f82e5a1bcad68042f41d7dc32030b60d3a538bf6..3817709e234b70a3dd7694542caf170eec9a0f41 100644
--- a/app/ui/legacy/src/main/res/values-es/strings.xml
+++ b/app/ui/legacy/src/main/res/values-es/strings.xml
@@ -341,9 +341,6 @@
     <string name="spam_folder_label">Carpeta Spam</string>
     <string name="account_setup_incoming_subscribed_folders_only_label">Ver sólo carpetas suscritas</string>
     <string name="account_setup_auto_expand_folder">Autoexpandir carpeta</string>
-    <string name="account_setup_incoming_webdav_path_prefix_label">Dirección WebDAV (Exchange)</string>
-    <string name="account_setup_incoming_webdav_auth_path_label">Dirección de autentificación</string>
-    <string name="account_setup_incoming_webdav_mailbox_path_label">Alias del buzón</string>
     <string name="account_setup_outgoing_title">Configuración de correo saliente</string>
     <string name="account_setup_outgoing_smtp_server_label">Servidor SMTP</string>
     <string name="account_setup_outgoing_port_label">Puerto</string>
@@ -1085,4 +1082,6 @@ Puede mantener este mensaje y usarlo como copia de seguridad de su clave secreta
     <string name="clipboard_label_email_address">Dirección de correo</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
     <string name="clipboard_label_name_and_email_address">Nombre y dirección de correo</string>
-</resources>
\ No newline at end of file
+    <string name="push_notification_state_listening">Esperando correos electrónicos nuevos</string>
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-et/strings.xml b/app/ui/legacy/src/main/res/values-et/strings.xml
index fcd681b70282ac411a5d8f8e12cb1a248eb37b01..ef727c236f103a97cc004e77d2dda11d0072a45c 100644
--- a/app/ui/legacy/src/main/res/values-et/strings.xml
+++ b/app/ui/legacy/src/main/res/values-et/strings.xml
@@ -384,8 +384,11 @@
     <string name="account_setup_failed_dlg_title">Seadistamist polnud võimalik lõpetada</string>
     <string name="account_setup_failed_dlg_auth_message_fmt">Vale kasutajanimi või salasõna.\n(<xliff:g id="error">%s</xliff:g>)</string>
     <string name="account_setup_failed_dlg_certificate_message_fmt">Server esitles vigast SSL sertifikaati. Mõnikord juhtub see serveri vale konfiguratsiooni tõttu. Mõnikord seetõttu, et keegi proovib rünnata Sind või Sinu meiliserverit. Kui Sa ei ole kindel mis toimub, klõpsa Tühista ja võta ühendust tegelastega, kes haldavad su meiliserverit.
-
 (<xliff:g id="error">%s</xliff:g>)</string>
+    <!--Title of an error notification that is displayed when creating a notification for a new message has failed-->
+    <string name="notification_notify_error_title">Viga teavitusel</string>
+    <string name="notification_channel_push_title">Sünkroniseeri (kasuta tõuketeenust)</string>
+    <string name="account_setup_incoming_send_client_id">Saada kliendi tunnus</string>
     <string name="account_setup_failed_dlg_server_message_fmt">Ei saa serveriga ühendust.\n(<xliff:g id="error">%s</xliff:g>)</string>
     <string name="account_setup_failed_dlg_oauth_flow_canceled">Autentimine on katkenud</string>
     <string name="account_setup_failed_dlg_oauth_flow_failed">Autentimine ei õnnestunud ja tekkis järgnev viga: <xliff:g id="error">%s</xliff:g></string>
@@ -1071,4 +1074,5 @@ Palun jäta see kiri alles ning kasuta seda muu hulgas oma krüptovõtme varunda
     <string name="clipboard_label_email_address">E-posti aadress</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
     <string name="clipboard_label_name_and_email_address">Nimi ja e-posti aadress</string>
-</resources>
\ No newline at end of file
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-eu/strings.xml b/app/ui/legacy/src/main/res/values-eu/strings.xml
index 57c007c364eb1b871dc3f788a6d5e33faa4c464c..5cd089363ce5e8131b38955bfca50f477ef8c9d7 100644
--- a/app/ui/legacy/src/main/res/values-eu/strings.xml
+++ b/app/ui/legacy/src/main/res/values-eu/strings.xml
@@ -1046,7 +1046,7 @@ Mezu hau gorde dezakezu eta zure gako sekretuaren babes-kopia gisa erabili. Hau
     <!--Name of the swipe action to move a message to the Spam folder. Try to keep it short.-->
     <string name="swipe_action_spam">Zabor-posta</string>
     <!--Name of the swipe action to move a message. The ellipsis (…) indicates that there is another step (selecting a folder) before the action is performed. Try to keep it short.-->
-    <string name="swipe_action_move">Mugitu...</string>
+    <string name="swipe_action_move">Mugitu…</string>
     <!--Name of setting to configure whether to show a "compose" floating action button on top of the message list-->
     <string name="general_settings_show_compose_button_title">Erakutsi idazteko botoi flotagarria</string>
     <!--Displayed in the toolbar when there was an error loading the message list, e.g. because the folder no longer exists.-->
@@ -1075,4 +1075,5 @@ Mezu hau gorde dezakezu eta zure gako sekretuaren babes-kopia gisa erabili. Hau
     <!--A user visible label for the email address copied to the clipboard-->
     <string name="clipboard_label_email_address">Posta helbidea</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
-</resources>
\ No newline at end of file
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-fa/strings.xml b/app/ui/legacy/src/main/res/values-fa/strings.xml
index ed41013c1d65bb6d7576236659649b7ad8ae4fff..1ce8831ff2ffa1672944ea02e488442cf52aa617 100644
--- a/app/ui/legacy/src/main/res/values-fa/strings.xml
+++ b/app/ui/legacy/src/main/res/values-fa/strings.xml
@@ -309,7 +309,6 @@
     <string name="account_setup_incoming_client_certificate_label">گواهی کارخواه</string>
     <string name="account_setup_incoming_pop_server_label">کارساز POP3</string>
     <string name="account_setup_incoming_imap_server_label">کارساز IMAP</string>
-    <string name="account_setup_incoming_webdav_server_label">کارساز Exchange</string>
     <string name="account_setup_incoming_port_label">درگاه</string>
     <string name="account_setup_incoming_security_label">امنیت</string>
     <string name="account_setup_incoming_auth_type_label">احراز هویت</string>
@@ -335,9 +334,6 @@
     <string name="spam_folder_label">پوشهٔ هرزنامه</string>
     <string name="account_setup_incoming_subscribed_folders_only_label">فقط پوشه‌هایی که مشترک آن‌ها هستم را نمایش بده</string>
     <string name="account_setup_auto_expand_folder">پوشهٔ آغازین</string>
-    <string name="account_setup_incoming_webdav_path_prefix_label">مسیر OWA</string>
-    <string name="account_setup_incoming_webdav_auth_path_label">مسیر احراز هویت</string>
-    <string name="account_setup_incoming_webdav_mailbox_path_label">نام مستعار صندوق پستی</string>
     <string name="account_setup_outgoing_title">تنظیمات کارساز خروجی </string>
     <string name="account_setup_outgoing_smtp_server_label">کارساز SMTP</string>
     <string name="account_setup_outgoing_port_label">درگاه</string>
@@ -1003,6 +999,39 @@
 
 می‌توانید این پیام را پیش خود نگه دارید و آن را به‌عنوان پشتیبان کلید سرّی‌تان به‌کار ببرید. برای انجام این کار باید گذرواژه را یادداشت و در جای امنی نگهداری کنید.
 </string>
+    <string name="source_code">کد منبع</string>
+    <!--Button text of the "snack bar" that is displayed when the app was updated.-->
+    <string name="changelog_snackbar_button_text">نما</string>
+    <string name="choose_folder_move_title">انتقال به…</string>
+    <string name="choose_folder_copy_title">کپی به…</string>
+    <!--Displayed in the message view screen in front of the recipient list. For most languages this should end with a space.-->
+    <string name="message_view_recipient_prefix">به</string>
+    <!--Displayed in the message view screen in front of the number of additional recipients (the ones that are not displayed).-->
+    <!--Displayed in the message view screen if the message was addressed to the user. Make sure this works with 'message_view_recipient_prefix'. In English it's "to me".-->
+    <string name="message_view_me_text">من</string>
+    <!--Text of the button that is displayed below the message header when the message body references one or more remote images-->
+    <string name="message_view_show_remote_images_action">نمایش تصاویر خارجی</string>
+    <!--Title of the screen to configure swipe actions-->
+    <string name="general_settings_swipe_actions_title">عملکردهای کشیدن</string>
+    <!--Name of the setting to configure the right swipe action-->
+    <string name="general_settings_right_swipe_title">کشیدن به راست</string>
+    <!--Name of the setting to configure the left swipe action-->
+    <string name="general_settings_left_swipe_title">کشیدن به چپ</string>
+    <!--Name of the swipe action to select/deselect a message-->
+    <string name="general_settings_swipe_action_toggle_selection">فعال/غیرفعال کردن انتخاب</string>
+    <!--Name of the swipe action to mark as message as read/unread-->
+    <string name="general_settings_swipe_action_toggle_read">برچسب زدن خوانده شده/خوانده نشده</string>
+    <!--Name of the swipe action to add/remove a star-->
+    <string name="general_settings_swipe_action_toggle_star">افزودن/حذف ستاره</string>
+    <!--Title of the setting to specify the density of the message list-->
+    <string name="general_settings_message_list_density_title">تراکم</string>
+    <string name="general_settings_ui_density_compact">فشرده</string>
+    <string name="general_settings_ui_density_relaxed">راحت</string>
+    <string name="account_setup_incoming_send_client_id">ارسال Client ID</string>
+    <string name="account_settings_notification_channels_label">دسته‌بندی‌های اعلان</string>
+    <string name="account_settings_open_notification_settings_messages_summary">اعلان برای پیام‌های جدید را پیکربندی کنید</string>
+    <string name="account_settings_open_notification_settings_miscellaneous_summary">اعلان‌های وضعیت و خطا را پیکربندی کنید</string>
+    <string name="font_size_message_view_recipients">گیرنده‌ها</string>
     <string name="ac_transfer_error_send">هنگام ارسال پیام خطایی رخ داد. لطفاً اتصال شبکه‌تان و پیکربندی کارساز خروجی را بررسی کنید.</string>
     <string name="switch_on">روشن</string>
     <string name="switch_off">خاموش</string>
@@ -1064,4 +1093,33 @@
     <!--A user visible label for the email address copied to the clipboard-->
     <string name="clipboard_label_email_address">نشانی رایانامه </string>
     <!--A user visible label for the name and email address copied to the clipboard-->
-</resources>
\ No newline at end of file
+    <!--Name of the swipe action to select a message. Try to keep it short.-->
+    <string name="swipe_action_select">انتخاب</string>
+    <!--Name of the swipe action to mark a message as read. Try to keep it short.-->
+    <string name="swipe_action_mark_as_read">علامت‌گذاری به‌عنوان خوانده شده</string>
+    <!--Name of the swipe action to move a message. The ellipsis (…) indicates that there is another step (selecting a folder) before the action is performed. Try to keep it short.-->
+    <string name="swipe_action_move">انتقال</string>
+    <!--Name of setting to configure whether to show a "compose" floating action button on top of the message list-->
+    <string name="general_settings_show_compose_button_title">نمایش دکمه نوشتن شناور</string>
+    <!--Displayed in the toolbar when there was an error loading the message list, e.g. because the folder no longer exists.-->
+    <string name="message_list_error_title">خطا</string>
+    <!--Displayed instead of the message list when a folder couldn't be found, e.g. due to an outdated home screen shortcut.-->
+    <string name="message_list_error_folder_not_found">پوشه پیدا نشد</string>
+    <!--Title of the toolbar that is displayed when the message details bottom sheet has been expanded-->
+    <string name="message_details_toolbar_title">جزییات پیام</string>
+    <!--Displayed when an email is missing the 'Date' header field and no date can be displayed in the message details bottom sheet.-->
+    <string name="message_details_missing_date">سرآیند تاریخ فراموش شده</string>
+    <!--Displayed when loading the message details has failed-->
+    <string name="message_details_loading_error">هنگام بارگیری جزییات پیام خطایی رخ داد.</string>
+    <!--Name of the action to add a person to contacts. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+    <string name="action_add_to_contacts">افزودن به مخاطبان</string>
+    <!--Name of the action to compose a new message to a particular address. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+    <string name="action_compose_message_to">نوشتن پیام به</string>
+    <!--Name of the action to copy an email address to the clipboard. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+    <string name="action_copy_email_address">کپی آدرس ایمیل</string>
+    <!--Name of the action to copy a name and email address to the clipboard. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+    <string name="action_copy_name_and_email_address">کپی نام و آدرس ایمیل</string>
+    <!--A user visible label for the name and email address copied to the clipboard-->
+    <string name="clipboard_label_name_and_email_address">نام و آدرس ایمیل</string>
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-fi/strings.xml b/app/ui/legacy/src/main/res/values-fi/strings.xml
index 3f05f1a8b1c6c6ccc3220e117c21368912e4e2d1..a2f7b694f6392cde81bf348ff8e525c64b7c9ee0 100644
--- a/app/ui/legacy/src/main/res/values-fi/strings.xml
+++ b/app/ui/legacy/src/main/res/values-fi/strings.xml
@@ -334,7 +334,6 @@ Ilmoita virheistä, ota osaa sovelluskehitykseen ja esitä kysymyksiä osoittees
     <string name="account_setup_incoming_client_certificate_label">Asiakasvarmenne</string>
     <string name="account_setup_incoming_pop_server_label">POP3-palvelin</string>
     <string name="account_setup_incoming_imap_server_label">IMAP-palvelin</string>
-    <string name="account_setup_incoming_webdav_server_label">Exchange-palvelin</string>
     <string name="account_setup_incoming_port_label">Portti</string>
     <string name="account_setup_incoming_security_label">Suojauksen tyyppi</string>
     <string name="account_setup_incoming_auth_type_label">Todennuksen tyyppi</string>
@@ -360,9 +359,6 @@ Ilmoita virheistä, ota osaa sovelluskehitykseen ja esitä kysymyksiä osoittees
     <string name="spam_folder_label">Roskapostikansio</string>
     <string name="account_setup_incoming_subscribed_folders_only_label">Näytä vain tilatut kansiot</string>
     <string name="account_setup_auto_expand_folder">Avaa kansio automaattisesti</string>
-    <string name="account_setup_incoming_webdav_path_prefix_label">OWA-polku</string>
-    <string name="account_setup_incoming_webdav_auth_path_label">Autentikointipolku</string>
-    <string name="account_setup_incoming_webdav_mailbox_path_label">Postilaatikon polku</string>
     <string name="account_setup_outgoing_title">Lähtevän postin palvelimen asetukset</string>
     <string name="account_setup_outgoing_smtp_server_label">SMTP-palvelin</string>
     <string name="account_setup_outgoing_port_label">Portti</string>
@@ -1070,4 +1066,41 @@ Voit säilyttää tämän viestin ja käyttää sitä varmuuskopioina salausavai
     <string name="preferences_authors">Tekijät</string>
     <string name="preferences_service_terms">Palveluehdot</string>
     <string name="preferences_privacy_policy">Tietosuojakäytäntö</string>
-</resources>
\ No newline at end of file
+    <!--Name of setting to configure whether to show a "compose" floating action button on top of the message list-->
+    <string name="general_settings_show_compose_button_title">Näytä kelluva kirjoituspainike</string>
+    <!--Displayed in the toolbar when there was an error loading the message list, e.g. because the folder no longer exists.-->
+    <string name="message_list_error_title">Virhe</string>
+    <!--Displayed instead of the message list when a folder couldn't be found, e.g. due to an outdated home screen shortcut.-->
+    <string name="message_list_error_folder_not_found">Kansiota ei löytynyt</string>
+    <!--Title of the toolbar that is displayed when the message details bottom sheet has been expanded-->
+    <string name="message_details_toolbar_title">Viestin tiedot</string>
+    <!--Displayed when an email is missing the 'Date' header field and no date can be displayed in the message details bottom sheet.-->
+    <string name="message_details_missing_date">Puuttuva \'Date\'-otsake</string>
+    <!--Title of the "From" section in the message details bottom sheet. This should probably be the same as the string 'recipient_from'.-->
+    <string name="message_details_from_section_title">Lähettäjä</string>
+    <!--Title of the "Sender" section in the message details bottom sheet. This refers to the 'Sender' header. Be careful with translations.-->
+    <string name="message_details_sender_section_title">Lähettäjä</string>
+    <!--Title of the "Reply to" section in the message details bottom sheet. This should probably be the same as the string 'reply_to_label'.-->
+    <string name="message_details_replyto_section_title">Vastausosoite</string>
+    <!--Title of the "To" section in the message details bottom sheet. This should probably be the same as the string 'recipient_to'.-->
+    <string name="message_details_to_section_title">Vastaanottaja</string>
+    <!--Title of the "Cc" section in the message details bottom sheet. This should probably be the same as the string 'recipient_cc'.-->
+    <string name="message_details_cc_section_title">Kopio</string>
+    <!--Title of the "Bcc" section in the message details bottom sheet. This should probably be the same as the string 'recipient_bcc'.-->
+    <string name="message_details_bcc_section_title">Piilokopio</string>
+    <!--Displayed when loading the message details has failed-->
+    <string name="message_details_loading_error">Viestin tietoja ladatessa tapahtui virhe.</string>
+    <!--Name of the action to add a person to contacts. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+    <string name="action_add_to_contacts">Lisää yhteystietoihin</string>
+    <!--Name of the action to compose a new message to a particular address. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+    <string name="action_compose_message_to">Kirjoita viesti osoitteeseen</string>
+    <!--Name of the action to copy an email address to the clipboard. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+    <string name="action_copy_email_address">Kopioi sähköpostiosoite</string>
+    <!--Name of the action to copy a name and email address to the clipboard. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+    <string name="action_copy_name_and_email_address">Kopioi nimi ja sähköpostiosoitteet</string>
+    <!--A user visible label for the email address copied to the clipboard-->
+    <string name="clipboard_label_email_address">Sähköpostiosoite</string>
+    <!--A user visible label for the name and email address copied to the clipboard-->
+    <string name="clipboard_label_name_and_email_address">Nimi ja sähköpostiosoitteet</string>
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-fr/strings.xml b/app/ui/legacy/src/main/res/values-fr/strings.xml
index 3663114cdfc0adcd8ce42d2393f4293ab4bb079c..4ca4dc2cfa7c556a0dfd24ab42d0bc7695da19b9 100644
--- a/app/ui/legacy/src/main/res/values-fr/strings.xml
+++ b/app/ui/legacy/src/main/res/values-fr/strings.xml
@@ -287,7 +287,6 @@ jusqu’à <xliff:g id="messages_to_load">%d</xliff:g> de plus</string>
     <string name="account_setup_incoming_client_certificate_label">Certificat client</string>
     <string name="account_setup_incoming_pop_server_label">Serveur POP3</string>
     <string name="account_setup_incoming_imap_server_label">Serveur IMAP</string>
-    <string name="account_setup_incoming_webdav_server_label">Serveur Exchange (WebDAV)</string>
     <string name="account_setup_incoming_port_label">Port</string>
     <string name="account_setup_incoming_security_label">Sécurité</string>
     <string name="account_setup_incoming_auth_type_label">Authentification</string>
@@ -313,9 +312,6 @@ jusqu’à <xliff:g id="messages_to_load">%d</xliff:g> de plus</string>
     <string name="spam_folder_label">Dossier des pourriels</string>
     <string name="account_setup_incoming_subscribed_folders_only_label">Afficher seulement les dossiers auxquels je suis abonné</string>
     <string name="account_setup_auto_expand_folder">Ouvrir automatiquement le dossier</string>
-    <string name="account_setup_incoming_webdav_path_prefix_label">Chemin OWA</string>
-    <string name="account_setup_incoming_webdav_auth_path_label">Chemin d’authentification</string>
-    <string name="account_setup_incoming_webdav_mailbox_path_label">Alias de la boîte de courriels</string>
     <string name="account_setup_outgoing_title">Paramètres du serveur sortant</string>
     <string name="account_setup_outgoing_smtp_server_label">Serveur SMTP</string>
     <string name="account_setup_outgoing_port_label">Port</string>
@@ -1076,4 +1072,18 @@ jusqu’à <xliff:g id="messages_to_load">%d</xliff:g> de plus</string>
     <string name="clipboard_label_email_address">Adresse e-mail</string>
     <string name="clipboard_label_name_and_email_address">Nom et adresse e-mail</string>
     <string name="welcome_message_text">Paramétrez un nouveau compte ou importez des comptes e-mail depuis un fichier de paramétrages.</string>
+    <!--Displayed in the message view screen in front of the number of additional recipients (the ones that are not displayed).-->
+    <string name="message_view_additional_recipient_prefix">+</string>
+    <!--Title of the setting to specify the density of the message list-->
+    <string name="general_settings_message_list_density_title">Densité</string>
+    <string name="general_settings_ui_density_compact">Compacte</string>
+    <string name="general_settings_ui_density_default">Par défaut</string>
+    <string name="general_settings_ui_density_relaxed">Détendue</string>
+    <string name="account_setup_check_settings_title" />
+    <string name="account_setup_incoming_send_client_id">Envoyer l’ID client</string>
+    <!--Displayed in the font size settings screen to configure the font size of the account name in the message view.-->
+    <string name="font_size_message_view_account">Nom des comptes</string>
+    <!--Name of the action to compose a new message to a particular address. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+    <string name="action_compose_message_to">Rédiger un courriel </string>
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
 </resources>
diff --git a/app/ui/legacy/src/main/res/values-fy/strings.xml b/app/ui/legacy/src/main/res/values-fy/strings.xml
index b9a006ae9aa991ffe13897dc220478f3a2d5c791..46f86b8c08c78d1c20ad579c687fbeaf4536ac10 100644
--- a/app/ui/legacy/src/main/res/values-fy/strings.xml
+++ b/app/ui/legacy/src/main/res/values-fy/strings.xml
@@ -1113,4 +1113,5 @@ Jo kinne dit berjocht bewarje as reservekopy foar jo geheime kaai. As jo dit dwa
     <string name="clipboard_label_email_address">E-mailadres</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
     <string name="clipboard_label_name_and_email_address">Namme en e-mailadres</string>
-</resources>
\ No newline at end of file
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-gd/strings.xml b/app/ui/legacy/src/main/res/values-gd/strings.xml
index 597f951305675d5eab6b4ec5e335c675f6b02d0f..fc064c6a484687675f54f48c4b4d7d1a3921255b 100644
--- a/app/ui/legacy/src/main/res/values-gd/strings.xml
+++ b/app/ui/legacy/src/main/res/values-gd/strings.xml
@@ -927,4 +927,5 @@
     <!--A user visible label for the email address copied to the clipboard-->
     <string name="clipboard_label_email_address">Seòladh puist-d</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
-</resources>
\ No newline at end of file
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-gl/strings.xml b/app/ui/legacy/src/main/res/values-gl/strings.xml
index 4b2fa6bebe7aa8ee9fc3529473550248f1e70f93..29cd2ee8c6a6da826e4053328268960dc2b31b54 100644
--- a/app/ui/legacy/src/main/res/values-gl/strings.xml
+++ b/app/ui/legacy/src/main/res/values-gl/strings.xml
@@ -295,7 +295,6 @@
     <string name="account_setup_incoming_client_certificate_label">Certificado cliente</string>
     <string name="account_setup_incoming_pop_server_label">Servidor POP3</string>
     <string name="account_setup_incoming_imap_server_label">Servidor IMAP</string>
-    <string name="account_setup_incoming_webdav_server_label">Servidor WebDAV (Exchange)</string>
     <string name="account_setup_incoming_port_label">Porto</string>
     <string name="account_setup_incoming_security_label">Tipo de Seguridade</string>
     <string name="account_setup_incoming_auth_type_label">Tipo de autentificación</string>
@@ -320,9 +319,6 @@
     <string name="spam_folder_label">Carpeta SPAM</string>
     <string name="account_setup_incoming_subscribed_folders_only_label">Ver só carpetas	suscritas</string>
     <string name="account_setup_auto_expand_folder">Autoexpandir carpeta</string>
-    <string name="account_setup_incoming_webdav_path_prefix_label">Enderezo WebDAV (Exchange)</string>
-    <string name="account_setup_incoming_webdav_auth_path_label">Enderezo de autentificación</string>
-    <string name="account_setup_incoming_webdav_mailbox_path_label">Enderezo buzón</string>
     <string name="account_setup_outgoing_title">Correo Sainte</string>
     <string name="account_setup_outgoing_smtp_server_label">Servidor SMTP</string>
     <string name="account_setup_outgoing_port_label">Porto</string>
@@ -1026,4 +1022,5 @@ Podes conservar esta mensaxe e usala como copia de seguridade da túa chave secr
     <!--A user visible label for the email address copied to the clipboard-->
     <string name="clipboard_label_email_address">Enderezo electrónico</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
-</resources>
\ No newline at end of file
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-hr/strings.xml b/app/ui/legacy/src/main/res/values-hr/strings.xml
index 3efa626e2ad63d37b166f80f90bacb53e7503e8e..5337066c4c82e557ad9f2917e4901342f8ebe19e 100644
--- a/app/ui/legacy/src/main/res/values-hr/strings.xml
+++ b/app/ui/legacy/src/main/res/values-hr/strings.xml
@@ -405,7 +405,7 @@
     <string name="account_settings_crypto_key">Podešavanje ključa za s kraja na kraj</string>
     <string name="account_settings_crypto_summary_off">OpenPGP aplikacija nije podešena</string>
     <string name="account_settings_crypto_summary_on">Povezano na %s</string>
-    <string name="account_settings_crypto_summary_config">Podešavam...</string>
+    <string name="account_settings_crypto_summary_config">Podešavam…</string>
     <string name="account_settings_crypto_encrypt_all_drafts">Pohrani sve skice šifrirano</string>
     <string name="account_settings_crypto_encrypt_all_drafts_on">Sve skice će biti pohranjene šifrirano</string>
     <string name="account_settings_crypto_encrypt_all_drafts_off">Šifriraj skice samo ukoliko je šifriranje uključeno</string>
@@ -880,7 +880,7 @@
     <string name="crypto_no_provider_message">Ova e-poruka je šifrirana korištenjem OpenPGP.\nDa bi ste je pročitali, potrebno je da instalirate i postavite odgovarajuću OpenPGP aplikaciju.</string>
     <string name="crypto_no_provider_button">Idi u Postavke</string>
     <string name="mail_list_widget_text">Mail Popis Poruka</string>
-    <string name="mail_list_widget_loading">Učitavam poruke...</string>
+    <string name="mail_list_widget_loading">Učitavam poruke…</string>
     <!--Displayed in the the message list widget when the app hasn't had a chance to send content to it yet-->
     <string name="message_list_widget_initializing">Učitavam…</string>
     <!--Might be displayed in the message list widget when the list is scrolled and new data can't be fetched fast enough-->
@@ -908,7 +908,7 @@
     <string name="ac_transfer_setting_summary">Sigurno podijeli podešavanja s kraja na kraj sa drugim uređajima</string>
     <string name="ac_transfer_button_send">Pošalji poruku za podešavanje</string>
     <string name="ac_transfer_will_be_sent">Poruka će biti poslana na vašu adresu:</string>
-    <string name="ac_transfer_generating">Generisanje poruke za podešavanje...</string>
+    <string name="ac_transfer_generating">Generisanje poruke za podešavanje…</string>
     <string name="ac_transfer_sending_to">Šaljem poruku:</string>
     <string name="ac_transfer_finish">Da bi završili, otvorite poruku na vašem drugom uređaju i unesite kod podešavanja.</string>
     <string name="ac_transfer_show_code">Prikaži kod podešavanja</string>
@@ -959,4 +959,5 @@
     <!--A user visible label for the email address copied to the clipboard-->
     <string name="clipboard_label_email_address">Adresa e-pošte</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
-</resources>
\ No newline at end of file
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-hu/strings.xml b/app/ui/legacy/src/main/res/values-hu/strings.xml
index 8800e9cd096ccc26454536fb3521f0e1e66bc8ba..e423a3c36c4107ae447fd9b2d371d9c0243138c4 100644
--- a/app/ui/legacy/src/main/res/values-hu/strings.xml
+++ b/app/ui/legacy/src/main/res/values-hu/strings.xml
@@ -1004,6 +1004,27 @@ Az új eszköz Autocrypthez történő beállításához kövesse az utasításo
 
 Megtarthatja ezt az üzenetet, és felhasználhatja a titkos kulcs biztonsági mentéséhez. Ha ezt szeretné tenni, akkor fel kell írnia a jelszót, és biztonságosan kell tárolnia.
 </string>
+    <!--Button text of the "snack bar" that is displayed when the app was updated.-->
+    <string name="changelog_snackbar_button_text">Megtekintés</string>
+    <string name="choose_folder_move_title">Áthelyezés…</string>
+    <string name="choose_folder_copy_title">Másolás…</string>
+    <!--Displayed in the message view screen in front of the recipient list. For most languages this should end with a space.-->
+    <string name="message_view_recipient_prefix">-&gt;</string>
+    <!--Displayed in the message view screen in front of the number of additional recipients (the ones that are not displayed).-->
+    <string name="message_view_additional_recipient_prefix">+</string>
+    <!--Displayed in the message view screen if the message was addressed to the user. Make sure this works with 'message_view_recipient_prefix'. In English it's "to me".-->
+    <string name="message_view_me_text">Számomra</string>
+    <!--Text of the button that is displayed below the message header when the message body references one or more remote images-->
+    <string name="message_view_show_remote_images_action">Távoli képek megjelenítése</string>
+    <!--Title of the setting to specify the density of the message list-->
+    <string name="general_settings_message_list_density_title">Sűrűség</string>
+    <string name="general_settings_ui_density_compact">Kompakt</string>
+    <string name="general_settings_ui_density_relaxed">Relaxált</string>
+    <string name="account_setup_incoming_send_client_id">Ügyfélazonosítót kell küldeni</string>
+    <string name="account_settings_notification_channels_label">Értesítési kategóriák</string>
+    <string name="account_settings_open_notification_settings_messages_summary">Értesítési beállítások az új üzenetekhez</string>
+    <string name="account_settings_open_notification_settings_miscellaneous_summary">Hiba- és állapotértesítések beállítása</string>
+    <string name="font_size_message_view_recipients">Címzettek</string>
     <string name="ac_transfer_error_send">Hiba történt az üzenet elküldése során. Ellenőrizze a hálózati kapcsolatot és a kimenő kiszolgáló beállítását.</string>
     <string name="switch_on">Be</string>
     <string name="switch_off">Ki</string>
@@ -1067,4 +1088,29 @@ Megtarthatja ezt az üzenetet, és felhasználhatja a titkos kulcs biztonsági m
     <!--A user visible label for the email address copied to the clipboard-->
     <string name="clipboard_label_email_address">E-mail-cím</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
-</resources>
\ No newline at end of file
+    <!--Name of setting to configure whether to show a "compose" floating action button on top of the message list-->
+    <string name="general_settings_show_compose_button_title">Lebegő levélírás-gomb megjelenítése</string>
+    <!--Displayed in the toolbar when there was an error loading the message list, e.g. because the folder no longer exists.-->
+    <string name="message_list_error_title">Hiba</string>
+    <!--Displayed instead of the message list when a folder couldn't be found, e.g. due to an outdated home screen shortcut.-->
+    <string name="message_list_error_folder_not_found">A mappa nem található</string>
+    <!--Title of the toolbar that is displayed when the message details bottom sheet has been expanded-->
+    <string name="message_details_toolbar_title">Üzenet részletei</string>
+    <!--Displayed when an email is missing the 'Date' header field and no date can be displayed in the message details bottom sheet.-->
+    <string name="message_details_missing_date">Hiányzik a „Dátum” fejléc</string>
+    <!--Title of the "Sender" section in the message details bottom sheet. This refers to the 'Sender' header. Be careful with translations.-->
+    <string name="message_details_sender_section_title">Feladó</string>
+    <!--Displayed when loading the message details has failed-->
+    <string name="message_details_loading_error">Hiba történt az üzenet részleteinek betöltése közben.</string>
+    <!--Name of the action to add a person to contacts. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+    <string name="action_add_to_contacts">Hozzáadás a Kapcsolatokhoz</string>
+    <!--Name of the action to compose a new message to a particular address. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+    <string name="action_compose_message_to">Üzenet írása, címzett:</string>
+    <!--Name of the action to copy an email address to the clipboard. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+    <string name="action_copy_email_address">E-mail cím másolása</string>
+    <!--Name of the action to copy a name and email address to the clipboard. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+    <string name="action_copy_name_and_email_address">Név és e-mail cím másolása</string>
+    <!--A user visible label for the name and email address copied to the clipboard-->
+    <string name="clipboard_label_name_and_email_address">Név és e-mail cím</string>
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-in/strings.xml b/app/ui/legacy/src/main/res/values-in/strings.xml
index 683e74bb5018c03c6b4fdc15cf7d1f12eaa223f1..d90fbc93072c785eb2ad2e87044d6da3846ba30c 100644
--- a/app/ui/legacy/src/main/res/values-in/strings.xml
+++ b/app/ui/legacy/src/main/res/values-in/strings.xml
@@ -415,7 +415,7 @@
     <string name="account_settings_crypto_key">Konfigurasikan kunci end-to-end</string>
     <string name="account_settings_crypto_summary_off">Tidak ada aplikasi OpenPGP yang dikonfigurasi</string>
     <string name="account_settings_crypto_summary_on">Terhubung dengan %s</string>
-    <string name="account_settings_crypto_summary_config">Mengkonfigurasi...</string>
+    <string name="account_settings_crypto_summary_config">Mengkonfigurasi…</string>
     <string name="account_settings_crypto_encrypt_all_drafts">Simpan semua konsep yang dienkripsi</string>
     <string name="account_settings_crypto_encrypt_all_drafts_on">Semua draft akan disimpan terenkripsi</string>
     <string name="account_settings_crypto_encrypt_all_drafts_off">Enkripsi draft hanya jika enkripsi diaktifkan</string>
@@ -562,7 +562,7 @@
     <string name="sort_unread_last">Pesan terbaca dulu</string>
     <string name="sort_attach_first">Pesan dengan lampiran dulu</string>
     <string name="sort_unattached_first">Pesan tanpa lampiran dulu</string>
-    <string name="sort_by">Sortir berdasar...</string>
+    <string name="sort_by">Sortir berdasar…</string>
     <string name="sort_by_date">Tanggal</string>
     <string name="sort_by_arrival">Kedatangan</string>
     <string name="sort_by_subject">Subyek</string>
@@ -575,7 +575,7 @@
     <string name="account_setup_failed_dlg_invalid_certificate_accept">Terima kunci</string>
     <string name="account_setup_failed_dlg_invalid_certificate_reject">Tolak kunci</string>
     <string name="folder_list_filter_hint">Nama folder mengandung</string>
-    <string name="folder_list_display_mode_label">Perlihatkan folder...</string>
+    <string name="folder_list_display_mode_label">Perlihatkan folder…</string>
     <string name="folder_list_display_mode_all">Semua folder</string>
     <string name="folder_list_display_mode_first_class">Folder kelas 1</string>
     <string name="folder_list_display_mode_first_and_second_class">Folder kelas 1 &amp; 2</string>
@@ -690,7 +690,7 @@
     <string name="settings_export_title">Ekspor pengaturan</string>
     <string name="settings_export_button">Ekspor</string>
     <string name="settings_export_share_button">Bagikan</string>
-    <string name="settings_export_progress_text">Mengekspor pengaturan...</string>
+    <string name="settings_export_progress_text">Mengekspor pengaturan…</string>
     <string name="settings_export_success_generic">Pengaturan berhasil diekspor</string>
     <string name="settings_export_failure">Gagal mengekspor pengaturan</string>
     <string name="settings_import_title">Impor pengaturan</string>
@@ -711,7 +711,7 @@
     <string name="settings_import_status_error">Kegagalan impor</string>
     <string name="settings_import_later_button">Nanti</string>
     <string name="settings_import">Impor pengaturan</string>
-    <string name="settings_importing">Mengimpor pengaturan...</string>
+    <string name="settings_importing">Mengimpor pengaturan…</string>
     <plurals name="settings_import_password_prompt">
         <item quantity="other">Untuk dapat menggunakan akun \"<xliff:g id="account">%s</xliff:g>\" Anda perlu memberikan kata sandi server.</item>
     </plurals>
@@ -719,7 +719,7 @@
     <string name="settings_import_outgoing_server_password_hint">Kata sandi server keluar</string>
     <string name="settings_import_use_same_password_for_outgoing_server">Gunakan kata sandi yang sama untuk server keluar</string>
     <string name="server_name_format">Nama server: <xliff:g id="hostname">%s</xliff:g></string>
-    <string name="unread_widget_select_account">Perlihatkan jumlah belum terbaca untuk...</string>
+    <string name="unread_widget_select_account">Perlihatkan jumlah belum terbaca untuk…</string>
     <string name="unread_widget_account_title">Akun</string>
     <string name="unread_widget_account_summary">Akun yang jumlah yang belum dibaca harus ditampilkan</string>
     <string name="unread_widget_unified_inbox_account_summary">Inbox terpadu</string>
@@ -777,7 +777,7 @@
     <string name="global_settings_threaded_view_label">Tampilan berulir</string>
     <string name="global_settings_threaded_view_summary">Kelompokkan pesan menurut percakapan</string>
     <string name="upgrade_databases_title">Mengupgrade database</string>
-    <string name="upgrade_databases_unspecified">Mengupgrade database...</string>
+    <string name="upgrade_databases_unspecified">Mengupgrade database…</string>
     <string name="upgrade_database_format">Mengupgrade database untuk akun \"<xliff:g id="account">%s</xliff:g>\"</string>
     <string name="global_settings_splitview_mode_label">Tampilkan layar terpisah</string>
     <string name="global_settings_splitview_always">Selalu</string>
@@ -791,10 +791,10 @@
     <string name="global_settings_colorize_missing_contact_pictures_summary">Warnai gambar kontak yang hilang</string>
     <string name="global_settings_messageview_visible_refile_actions_title">Tindakan pesan terlihat</string>
     <string name="global_settings_messageview_visible_refile_actions_summary">Tampilkan tindakan yang dipilih di menu tampilan pesan</string>
-    <string name="loading_attachment">Memuat lampiran...</string>
+    <string name="loading_attachment">Memuat lampiran…</string>
     <string name="fetching_attachment_dialog_title_send">Mengirim pesan</string>
     <string name="fetching_attachment_dialog_title_save">Menyimpan draf</string>
-    <string name="fetching_attachment_dialog_message">Mengambil lampiran...</string>
+    <string name="fetching_attachment_dialog_message">Mengambil lampiran…</string>
     <string name="auth_external_error">Tidak dapat melakukan otentikasi. Server tidak mengiklankan kemampuan SASL EXTERNAL. Ini bisa jadi karena masalah dengan sertifikat klien (kadaluarsa, otoritas sertifikat tidak diketahui) atau masalah konfigurasi lainnya.</string>
     <!--=== Client certificates specific ==================================================================-->
     <string name="account_setup_basics_client_certificate">Gunakan sertifikat klien</string>
@@ -881,7 +881,7 @@
     <string name="locked_attach_unlock">Buka kunci</string>
     <string name="locked_attach_unencrypted">Bagian ini tidak dienkripsi, dan mungkin tidak aman.</string>
     <string name="locked_attach_title">Lampiran tidak terlindungi</string>
-    <string name="message_progress_text">Memuat...</string>
+    <string name="message_progress_text">Memuat…</string>
     <string name="messageview_decrypt_cancelled">Dekripsi dibatalkan</string>
     <string name="messageview_decrypt_retry">Lanjut</string>
     <string name="messageview_decrypt_incomplete">Pesan terenkripsi harus diunduh untuk dekripsi.</string>
@@ -897,7 +897,7 @@
     <string name="crypto_no_provider_message">Email ini telah dienkripsi dengan OpenPGP. \nUntuk membacanya, Anda perlu menginstal dan mengkonfigurasi Aplikasi OpenPGP yang kompatibel.</string>
     <string name="crypto_no_provider_button">Pergi ke pengaturan</string>
     <string name="mail_list_widget_text">Daftar pesan Mail</string>
-    <string name="mail_list_widget_loading">Memuat pesan...</string>
+    <string name="mail_list_widget_loading">Memuat pesan…</string>
     <!--Displayed in the the message list widget when the app hasn't had a chance to send content to it yet-->
     <string name="message_list_widget_initializing">Memuat…</string>
     <!--Might be displayed in the message list widget when the list is scrolled and new data can't be fetched fast enough-->
@@ -933,7 +933,7 @@
     <string name="ac_transfer_intro">Pesan Pengaturan Autocrypt secara aman membagi pengaturan ujung ke ujung Anda dengan perangkat lain.</string>
     <string name="ac_transfer_button_send">Kirim Pesan Penyetelan</string>
     <string name="ac_transfer_will_be_sent">Pesan akan dikirim ke alamat Anda:</string>
-    <string name="ac_transfer_generating">Menghasilkan pesan pengaturan ...</string>
+    <string name="ac_transfer_generating">Menghasilkan pesan pengaturan …</string>
     <string name="ac_transfer_sending_to">Mengirim pesan ke:</string>
     <string name="ac_transfer_finish">Untuk menyelesaikan, buka pesan di perangkat Anda yang lain dan masukkan kode pengaturan.</string>
     <string name="ac_transfer_show_code">Tampilkan Kode Pengaturan</string>
@@ -993,4 +993,5 @@ Anda dapat menyimpan pesan ini dan menggunakannya sebagai cadangan untuk kunci r
     <!--A user visible label for the email address copied to the clipboard-->
     <string name="clipboard_label_email_address">Alamat surel</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
-</resources>
\ No newline at end of file
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-is/strings.xml b/app/ui/legacy/src/main/res/values-is/strings.xml
index d993c0258244ec70b198c4963b98ecb831a4fc48..fa1fa41603080cf458cc86bc361ac1df302ec39e 100644
--- a/app/ui/legacy/src/main/res/values-is/strings.xml
+++ b/app/ui/legacy/src/main/res/values-is/strings.xml
@@ -312,7 +312,6 @@
     <string name="account_setup_incoming_client_certificate_label">Skilríki forritsins</string>
     <string name="account_setup_incoming_pop_server_label">POP3-þjónn</string>
     <string name="account_setup_incoming_imap_server_label">IMAP-þjónn</string>
-    <string name="account_setup_incoming_webdav_server_label">Exchange-þjónn</string>
     <string name="account_setup_incoming_port_label">Gátt</string>
     <string name="account_setup_incoming_security_label">Öryggi</string>
     <string name="account_setup_incoming_auth_type_label">Auðkenning</string>
@@ -338,9 +337,6 @@
     <string name="spam_folder_label">Ruslpóstmappa</string>
     <string name="account_setup_incoming_subscribed_folders_only_label">Sýna einungis möppur í áskrift</string>
     <string name="account_setup_auto_expand_folder">Fletta möppu út sjálfvirkt</string>
-    <string name="account_setup_incoming_webdav_path_prefix_label">OWA-slóð</string>
-    <string name="account_setup_incoming_webdav_auth_path_label">Slóð auðkenningar</string>
-    <string name="account_setup_incoming_webdav_mailbox_path_label">Samnefni pósthólfs</string>
     <string name="account_setup_outgoing_title">Stillingar sendinga-póstþjóns</string>
     <string name="account_setup_outgoing_smtp_server_label">SMTP-þjónn</string>
     <string name="account_setup_outgoing_port_label">Gátt</string>
@@ -1106,4 +1102,5 @@
     <string name="account_setup_incoming_send_client_id">Senda auðkenni biðlara</string>
     <string name="font_size_message_view_account">Nafn aðgangsins</string>
     <string name="action_compose_message_to">Semja póst til</string>
-</resources>
\ No newline at end of file
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-it/strings.xml b/app/ui/legacy/src/main/res/values-it/strings.xml
index fcff6a756ab491a6f18c862100f74e1386d8f5d3..e4a890cb84c96310156eed37678f036b528f3482 100644
--- a/app/ui/legacy/src/main/res/values-it/strings.xml
+++ b/app/ui/legacy/src/main/res/values-it/strings.xml
@@ -277,7 +277,6 @@
     <string name="account_setup_incoming_client_certificate_label">Certificato client</string>
     <string name="account_setup_incoming_pop_server_label">Server POP3</string>
     <string name="account_setup_incoming_imap_server_label">Server IMAP</string>
-    <string name="account_setup_incoming_webdav_server_label">Server Exchange</string>
     <string name="account_setup_incoming_port_label">Porta</string>
     <string name="account_setup_incoming_security_label">Sicurezza</string>
     <string name="account_setup_incoming_auth_type_label">Autenticazione</string>
@@ -303,9 +302,6 @@
     <string name="spam_folder_label">Cartella Spam</string>
     <string name="account_setup_incoming_subscribed_folders_only_label">Mostra solo le cartelle sottoscritte</string>
     <string name="account_setup_auto_expand_folder">Auto-espandi cartella</string>
-    <string name="account_setup_incoming_webdav_path_prefix_label">Percorso OWA</string>
-    <string name="account_setup_incoming_webdav_auth_path_label">Percorso di autenticazione</string>
-    <string name="account_setup_incoming_webdav_mailbox_path_label">Alias della casella postale</string>
     <string name="account_setup_outgoing_title">Impostazioni server della posta in uscita</string>
     <string name="account_setup_outgoing_smtp_server_label">Server SMTP</string>
     <string name="account_setup_outgoing_port_label">Porta</string>
@@ -1091,4 +1087,5 @@ Puoi conservare questo messaggio e utilizza come una copia di sicurezza della tu
     <string name="account_setup_incoming_send_client_id">Invia ID client</string>
     <string name="font_size_message_view_account">Nome Account</string>
     <string name="action_compose_message_to">Scrivi messaggio per</string>
-</resources>
\ No newline at end of file
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-iw/strings.xml b/app/ui/legacy/src/main/res/values-iw/strings.xml
index c445b21e87505c02c3fa55a0637a313715c90e92..08424865b5695f6196303fe4a6b73c9221663ad8 100644
--- a/app/ui/legacy/src/main/res/values-iw/strings.xml
+++ b/app/ui/legacy/src/main/res/values-iw/strings.xml
@@ -37,8 +37,8 @@
     <string name="compose_title_forward_as_attachment">העבר כקובץ מצורף</string>
     <string name="choose_account_title">בחר חשבון</string>
     <string name="choose_folder_title">בחר תיקייה</string>
-    <string name="choose_folder_move_title">העבר אל...</string>
-    <string name="choose_folder_copy_title">העתק אל...</string>
+    <string name="choose_folder_move_title">העבר אל…</string>
+    <string name="choose_folder_copy_title">העתק אל…</string>
     <string name="actionbar_selected"><xliff:g id="selection_count">%d</xliff:g> נבחרו</string>
     <string name="next_action">הבא</string>
     <!--Used to confirm acceptance of dialog boxes, warnings, errors, etc.-->
@@ -647,4 +647,5 @@
     <!--A user visible label for the email address copied to the clipboard-->
     <string name="clipboard_label_email_address">כתובת דוא\"ל</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
-</resources>
\ No newline at end of file
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-ja/strings.xml b/app/ui/legacy/src/main/res/values-ja/strings.xml
index 7a751399569ea2d00ae21b2e63ee321445a1eb03..91d80d5ffcd616bc707e1a4b793a796ce63d59db 100644
--- a/app/ui/legacy/src/main/res/values-ja/strings.xml
+++ b/app/ui/legacy/src/main/res/values-ja/strings.xml
@@ -1087,4 +1087,5 @@
     <string name="clipboard_label_email_address">メールアドレス</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
     <string name="clipboard_label_name_and_email_address">名前とメールアドレス</string>
-</resources>
\ No newline at end of file
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-ko/strings.xml b/app/ui/legacy/src/main/res/values-ko/strings.xml
index 9cef142c73ddc53a7358aa473a6841f0af9923f3..d38bf12e777f74e46008a723a108d2a59518083f 100644
--- a/app/ui/legacy/src/main/res/values-ko/strings.xml
+++ b/app/ui/legacy/src/main/res/values-ko/strings.xml
@@ -285,7 +285,6 @@
     <string name="account_setup_incoming_client_certificate_label">클라이언트 인증서</string>
     <string name="account_setup_incoming_pop_server_label">POP3 서버</string>
     <string name="account_setup_incoming_imap_server_label">IMAP 서버</string>
-    <string name="account_setup_incoming_webdav_server_label">Exchange 서버</string>
     <string name="account_setup_incoming_port_label">포트 번호</string>
     <string name="account_setup_incoming_security_label">보안 연결</string>
     <string name="account_setup_incoming_auth_type_label">인증 방식</string>
@@ -309,9 +308,6 @@
     <string name="spam_folder_label">스팸 폴더</string>
     <string name="account_setup_incoming_subscribed_folders_only_label">설정한 폴더만 보기</string>
     <string name="account_setup_auto_expand_folder">폴더 자동 펼치기</string>
-    <string name="account_setup_incoming_webdav_path_prefix_label">OWA 경로</string>
-    <string name="account_setup_incoming_webdav_auth_path_label">인증 경로</string>
-    <string name="account_setup_incoming_webdav_mailbox_path_label">편지함 별명</string>
     <string name="account_setup_outgoing_title">보내기 서버 설정</string>
     <string name="account_setup_outgoing_smtp_server_label">SMTP 서버</string>
     <string name="account_setup_outgoing_port_label">포트번호</string>
@@ -851,4 +847,5 @@
     <!--A user visible label for the email address copied to the clipboard-->
     <string name="clipboard_label_email_address">전자우편 주소</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
-</resources>
\ No newline at end of file
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-lt/strings.xml b/app/ui/legacy/src/main/res/values-lt/strings.xml
index c2332258da073de72cf88cc430cf90dc738d9bc2..f2c736f9c8d0c9e5e113bc216bfafc4c2c9865ef 100644
--- a/app/ui/legacy/src/main/res/values-lt/strings.xml
+++ b/app/ui/legacy/src/main/res/values-lt/strings.xml
@@ -45,8 +45,8 @@
     <string name="compose_title_forward_as_attachment">Persiųsti kaip priedą</string>
     <string name="choose_account_title">Pasirinkti Paskyrą</string>
     <string name="choose_folder_title">Pasirinkti aplanką</string>
-    <string name="choose_folder_move_title">Perkelti į...</string>
-    <string name="choose_folder_copy_title">Kopijuoti į...</string>
+    <string name="choose_folder_move_title">Perkelti į…</string>
+    <string name="choose_folder_copy_title">Kopijuoti į…</string>
     <string name="actionbar_selected"><xliff:g id="selection_count">%d</xliff:g> pasirinkta</string>
     <string name="next_action">Kitas</string>
     <!--Used to confirm acceptance of dialog boxes, warnings, errors, etc.-->
@@ -315,7 +315,6 @@
     <string name="account_setup_incoming_client_certificate_label">Kliento sertifikatas</string>
     <string name="account_setup_incoming_pop_server_label">POP3 serveris</string>
     <string name="account_setup_incoming_imap_server_label">IMAP serveris</string>
-    <string name="account_setup_incoming_webdav_server_label">Mainų serveris</string>
     <string name="account_setup_incoming_port_label">Prievadas</string>
     <string name="account_setup_incoming_security_label">Saugumas</string>
     <string name="account_setup_incoming_auth_type_label">Tapatumo nustatymas</string>
@@ -341,9 +340,6 @@
     <string name="spam_folder_label">Brukalo aplankas</string>
     <string name="account_setup_incoming_subscribed_folders_only_label">Rodyti tik prenumeruotus aplankus</string>
     <string name="account_setup_auto_expand_folder">Automatiškai išskleisti aplanką</string>
-    <string name="account_setup_incoming_webdav_path_prefix_label">OWA kelias</string>
-    <string name="account_setup_incoming_webdav_auth_path_label">Tapatybės tikrinimo kelias</string>
-    <string name="account_setup_incoming_webdav_mailbox_path_label">Pašto dėžutės pavadinimas</string>
     <string name="account_setup_outgoing_title">Siunčiamųjų laiškų serveris</string>
     <string name="account_setup_outgoing_smtp_server_label">SMTP serveris</string>
     <string name="account_setup_outgoing_port_label">Prievadas</string>
@@ -458,7 +454,7 @@
     <string name="account_settings_crypto_key">Konfiguruoti visapusišką raktą</string>
     <string name="account_settings_crypto_summary_off">Nesukonfigūruota OpenPGP programa</string>
     <string name="account_settings_crypto_summary_on">Prisijungta prie %s</string>
-    <string name="account_settings_crypto_summary_config">Konfiguruojama...</string>
+    <string name="account_settings_crypto_summary_config">Konfiguruojama…</string>
     <string name="account_settings_crypto_encrypt_all_drafts">Laikyti visus juodraščius užšifruotus</string>
     <string name="account_settings_crypto_encrypt_all_drafts_on">Visi juodraščiai bus saugomi užšifruoti</string>
     <string name="account_settings_crypto_encrypt_all_drafts_off">Šifruoti juodraščius tik tada, jei įjungtas šifravimas</string>
@@ -975,7 +971,7 @@
     <string name="crypto_no_provider_message">Šis el. laiškas užšifruotas naudojant OpenPGP.\nKad jį perskaitytumėte, turite įdiegti ir sukonfigūruoti suderinamą OpenPGP programėlę.</string>
     <string name="crypto_no_provider_button">Eiti į Nustatymus</string>
     <string name="mail_list_widget_text">Mail laiškų sąrašas</string>
-    <string name="mail_list_widget_loading">Įkeliami laiškai...</string>
+    <string name="mail_list_widget_loading">Įkeliami laiškai…</string>
     <!--Displayed in the the message list widget when the app hasn't had a chance to send content to it yet-->
     <string name="message_list_widget_initializing">Įkeliama…</string>
     <!--Might be displayed in the message list widget when the list is scrolled and new data can't be fetched fast enough-->
@@ -1011,7 +1007,7 @@
     <string name="ac_transfer_intro">Automatinio šifravimo sąrankos laiške saugiai bendrinama visapuse sąranka su kitais prietaisais.</string>
     <string name="ac_transfer_button_send">Siųsti sąrankos laišką</string>
     <string name="ac_transfer_will_be_sent">Šis laiškas bus išsiųstas jūsų adresu:</string>
-    <string name="ac_transfer_generating">Generuojamas sąrankos laiškas...</string>
+    <string name="ac_transfer_generating">Generuojamas sąrankos laiškas…</string>
     <string name="ac_transfer_sending_to">Siunčiamas laiškas į:</string>
     <string name="ac_transfer_finish">Kad baigti, atidarykite laišką kitame prietaise ir įveskite sąrankos kodą.</string>
     <string name="ac_transfer_show_code">Rodyti sąrankos kodą</string>
@@ -1029,7 +1025,7 @@ Norėdami nustatyti automatinį šifravimą naujajame prietaise, vadovaukitės i
     <string name="permission_contacts_rationale_title">Leisti prieigą prie kontaktų</string>
     <string name="permission_contacts_rationale_message">Kad galėtų teikti kontaktų pasiūlymus ir rodyti kontaktų vardus bei nuotraukas, programėlei reikia prieigos prie jūsų kontaktų.</string>
     <string name="generic_loading_error">Įkeliant duomenis įvyko klaida</string>
-    <string name="push_notification_state_initializing">Inicializuojama...</string>
+    <string name="push_notification_state_initializing">Inicializuojama…</string>
     <string name="push_notification_state_listening">Laukiama naujų laiškų</string>
     <string name="push_notification_state_wait_background_sync">Miegama iki kol fono sinchronizacija bus leidžiama</string>
     <string name="push_notification_state_wait_network">Miegama, kol bus prieinamas tinklas</string>
@@ -1093,4 +1089,5 @@ Norėdami nustatyti automatinį šifravimą naujajame prietaise, vadovaukitės i
     <string name="clipboard_label_email_address">El. pašto adresas</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
     <string name="clipboard_label_name_and_email_address">Vardas ir el. pašto adresas</string>
-</resources>
\ No newline at end of file
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-lv/strings.xml b/app/ui/legacy/src/main/res/values-lv/strings.xml
index 526f41f9dca88189e37cec8a4d50b920741b3816..41625da506f7c15e5d6e5fe0bc2f2eb815cb21e5 100644
--- a/app/ui/legacy/src/main/res/values-lv/strings.xml
+++ b/app/ui/legacy/src/main/res/values-lv/strings.xml
@@ -1102,4 +1102,5 @@ Lai jaunajā ierīcē iestatītu automātisko šifrēšanu, lūdzu sekojiet nor
     <string name="clipboard_label_email_address">E-pasta adrese</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
     <string name="clipboard_label_name_and_email_address">Vārds un e-pasta adrese</string>
-</resources>
\ No newline at end of file
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-ml/strings.xml b/app/ui/legacy/src/main/res/values-ml/strings.xml
index 857f0a0d7dbce5f393e0484a614674dfd5f51ec6..0a7284c4dd8996c59d1d665c77c12e87b0da4e8c 100644
--- a/app/ui/legacy/src/main/res/values-ml/strings.xml
+++ b/app/ui/legacy/src/main/res/values-ml/strings.xml
@@ -48,8 +48,8 @@
     <string name="compose_title_forward_as_attachment">അറ്റാച്ചുമെന്റായി ഫോർവേഡ് ചെയ്യുക</string>
     <string name="choose_account_title">അക്കൗണ്ട് തിരഞ്ഞെടുക്കുക</string>
     <string name="choose_folder_title">ഫോൾഡർ തിരഞ്ഞെടുക്കുക</string>
-    <string name="choose_folder_move_title">ഇതിലേക്ക് നീക്കുക...</string>
-    <string name="choose_folder_copy_title">ഇതിലേക്ക് പകർത്തുക...</string>
+    <string name="choose_folder_move_title">ഇതിലേക്ക് നീക്കുക…</string>
+    <string name="choose_folder_copy_title">ഇതിലേക്ക് പകർത്തുക…</string>
     <string name="actionbar_selected"><xliff:g id="selection_count">%d</xliff:g> തിരഞ്ഞെടുത്തു</string>
     <string name="next_action">അടുത്തത്</string>
     <!--Used to confirm acceptance of dialog boxes, warnings, errors, etc.-->
@@ -804,7 +804,7 @@
     <string name="global_settings_threaded_view_label">ത്രെഡുചെയ്‌ത കാഴ്ച</string>
     <string name="global_settings_threaded_view_summary">സംഭാഷണത്തിലൂടെ സന്ദേശങ്ങൾ ഗ്രൂപ്പ് ചെയ്യുക</string>
     <string name="upgrade_databases_title">ഡാറ്റാബേസുകൾ‌ നവീകരിക്കുന്നു</string>
-    <string name="upgrade_databases_unspecified">ഡാറ്റാബേസുകൾ‌ നവീകരിക്കുന്നു...</string>
+    <string name="upgrade_databases_unspecified">ഡാറ്റാബേസുകൾ‌ നവീകരിക്കുന്നു…</string>
     <string name="upgrade_database_format">\"<xliff:g id="account">%s</xliff:g>\" അക്കൗണ്ടിന്റെ ഡാറ്റാബേസ് നവീകരിക്കുന്നു</string>
     <string name="global_settings_splitview_mode_label">പിളർ സ്ക്രീൻ കാണിക്കുക</string>
     <string name="global_settings_splitview_always">എല്ലായ്പ്പോഴും</string>
@@ -924,7 +924,7 @@
     <string name="crypto_no_provider_message">ഈ ഇമെയിൽ ഓപ്പൺപിജിപി ഉപയോഗിച്ച് എൻക്രിപ്റ്റുചെയ്‌തതാണ്.\nഇത് വായിക്കാൻ, നിങ്ങൾ ഒരു അനുയോജ്യമായ ഓപ്പൺപിജിപി അപ്ലിക്കേഷൻ ഇൻസ്റ്റാളുചെയ്‌ത് ക്രമീകരിക്കേണ്ടതുണ്ട്. </string>
     <string name="crypto_no_provider_button">ക്രമീകരണങ്ങളിലേക്ക് പോകുക</string>
     <string name="mail_list_widget_text">Mail സന്ദേശ പട്ടിക</string>
-    <string name="mail_list_widget_loading">സന്ദേശങ്ങൾ ലോഡുചെയ്യുന്നു...</string>
+    <string name="mail_list_widget_loading">സന്ദേശങ്ങൾ ലോഡുചെയ്യുന്നു…</string>
     <!--Displayed in the the message list widget when the app hasn't had a chance to send content to it yet-->
     <string name="message_list_widget_initializing">ലോഡുചെയ്യുന്നു…</string>
     <!--Might be displayed in the message list widget when the list is scrolled and new data can't be fetched fast enough-->
@@ -1019,4 +1019,5 @@
     <!--A user visible label for the email address copied to the clipboard-->
     <string name="clipboard_label_email_address">ഇമെയിൽ വിലാസം</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
-</resources>
\ No newline at end of file
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-nb/strings.xml b/app/ui/legacy/src/main/res/values-nb/strings.xml
index 195dbacb24a9f0a9da9ea42f1b796057df16af92..38882888561839785752e0f7261c1b5424c43a78 100644
--- a/app/ui/legacy/src/main/res/values-nb/strings.xml
+++ b/app/ui/legacy/src/main/res/values-nb/strings.xml
@@ -955,4 +955,5 @@ til <xliff:g id="messages_to_load">%d</xliff:g> flere</string>
     <!--A user visible label for the email address copied to the clipboard-->
     <string name="clipboard_label_email_address">E-postadresse</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
-</resources>
\ No newline at end of file
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-nl/strings.xml b/app/ui/legacy/src/main/res/values-nl/strings.xml
index ae965b3a61273fd25e1add282678431ca50947a5..d29693b4e24d3dde915522f34adc8d5ff10b462b 100644
--- a/app/ui/legacy/src/main/res/values-nl/strings.xml
+++ b/app/ui/legacy/src/main/res/values-nl/strings.xml
@@ -268,7 +268,6 @@
     <string name="account_setup_incoming_client_certificate_label">Client certificaat</string>
     <string name="account_setup_incoming_pop_server_label">POP3-server</string>
     <string name="account_setup_incoming_imap_server_label">IMAP-server</string>
-    <string name="account_setup_incoming_webdav_server_label">WebDAV (Exchange) server</string>
     <string name="account_setup_incoming_port_label">Poort</string>
     <string name="account_setup_incoming_security_label">Beveiligingstype</string>
     <string name="account_setup_incoming_auth_type_label">Authenticatietype</string>
@@ -294,9 +293,6 @@
     <string name="spam_folder_label">Spammap</string>
     <string name="account_setup_incoming_subscribed_folders_only_label">Alleen geabonneerde mappen weergeven</string>
     <string name="account_setup_auto_expand_folder">Map automatisch uitvouwen</string>
-    <string name="account_setup_incoming_webdav_path_prefix_label">WebDAV (Exchange) path</string>
-    <string name="account_setup_incoming_webdav_auth_path_label">Authenticatie pad</string>
-    <string name="account_setup_incoming_webdav_mailbox_path_label">Mailbox alias</string>
     <string name="account_setup_outgoing_title">Uitgaande server instellingen</string>
     <string name="account_setup_outgoing_smtp_server_label">SMTP-server</string>
     <string name="account_setup_outgoing_port_label">Poort</string>
@@ -1080,4 +1076,5 @@ U kunt dit bericht bewaren als backup voor uw geheime sleutel. Als u dit wilt do
     <string name="general_settings_message_list_density_title">Weergavedichtheid</string>
     <string name="changelog_snackbar_button_text">Bekijk</string>
     <string name="account_setup_incoming_send_client_id">Verstuur cliënt-ID</string>
-</resources>
\ No newline at end of file
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-pl/strings.xml b/app/ui/legacy/src/main/res/values-pl/strings.xml
index 86428032e9530cc95fa7f69088ee2d50b01ba4b2..11cb8a5ca03b965abaed793fe5ce31c8f3989ca3 100644
--- a/app/ui/legacy/src/main/res/values-pl/strings.xml
+++ b/app/ui/legacy/src/main/res/values-pl/strings.xml
@@ -1104,4 +1104,5 @@ Tą wiadomość można zachować i użyć w formie kopii zapasowej twojego klucz
     <string name="clipboard_label_email_address">Adres e-mail</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
     <string name="clipboard_label_name_and_email_address">Nazwa oraz adres e-mail</string>
-</resources>
\ No newline at end of file
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-pt-rBR/strings.xml b/app/ui/legacy/src/main/res/values-pt-rBR/strings.xml
index bd2fd8e2d5bded41367d40003d7e80b30fd2b30a..21bbb4ed422357d5fdec0cdbd14fc9ac78f068a8 100644
--- a/app/ui/legacy/src/main/res/values-pt-rBR/strings.xml
+++ b/app/ui/legacy/src/main/res/values-pt-rBR/strings.xml
@@ -1102,4 +1102,5 @@ Você pode guardar esta mensagem e usá-la como um backup da sua chave secreta.
   <string name="clipboard_label_email_address">Endereço de e-mail</string>
   <!--A user visible label for the name and email address copied to the clipboard-->
   <string name="clipboard_label_name_and_email_address">Nome e endereço de e-mail</string>
+  <!--Might be displayed in a notification when deleting an account (in the background)-->
 </resources>
diff --git a/app/ui/legacy/src/main/res/values-pt-rPT/strings.xml b/app/ui/legacy/src/main/res/values-pt-rPT/strings.xml
index b98d295c94d8548e91e8a91f2709d4e9256a9e51..5928d6c5845bb52a8b5d6c494a68ef5516ae5db2 100644
--- a/app/ui/legacy/src/main/res/values-pt-rPT/strings.xml
+++ b/app/ui/legacy/src/main/res/values-pt-rPT/strings.xml
@@ -27,6 +27,7 @@
   <!--Displayed in a "snack bar" at the bottom of the screen when the app was updated.-->
   <string name="changelog_snackbar_text">Descubra o que há de novo nesta versão</string>
   <!--Button text of the "snack bar" that is displayed when the app was updated.-->
+  <string name="changelog_snackbar_button_text">Ver</string>
   <!--Welcome message-->
   <string name="welcome_message_title">Welcome to Mail</string>
   <string name="accounts_welcome">Mail is the default mail client for /e/</string>
@@ -201,9 +202,13 @@
   <string name="message_view_bcc_label">Bcc:</string>
   <string name="message_view_status_attachment_not_saved">Não foi possível guardar o anexo</string>
   <!--Displayed in the message view screen in front of the recipient list. For most languages this should end with a space.-->
+  <string name="message_view_recipient_prefix">"para "</string>
   <!--Displayed in the message view screen in front of the number of additional recipients (the ones that are not displayed).-->
+  <string name="message_view_additional_recipient_prefix">+</string>
   <!--Displayed in the message view screen if the message was addressed to the user. Make sure this works with 'message_view_recipient_prefix'. In English it's "to me".-->
+  <string name="message_view_me_text">eu</string>
   <!--Text of the button that is displayed below the message header when the message body references one or more remote images-->
+  <string name="message_view_show_remote_images_action">Mostrar imagens remotas</string>
   <string name="message_view_no_viewer">Incapaz de encontrar visualizador para <xliff:g id="mimetype">%s</xliff:g>.</string>
   <string name="message_view_download_remainder">Transferir mensagem completa</string>
   <string name="message_view_sender_label">via %1$s</string>
@@ -239,6 +244,7 @@
   <string name="global_settings_confirm_menu_mark_all_read">Marcar todas as mensagens como lidas</string>
   <string name="global_settings_confirm_action_delete_notif">Eliminar (a partir da notificação)</string>
   <!--Title of the screen to configure swipe actions-->
+  <string name="general_settings_swipe_actions_title">Ações de deslize</string>
   <!--Name of the setting to configure the right swipe action-->
   <string name="general_settings_right_swipe_title">Deslizo para a direita</string>
   <!--Name of the setting to configure the left swipe action-->
@@ -246,9 +252,11 @@
   <!--The list item users select to not use a swipe action for a particular direction-->
   <string name="general_settings_swipe_action_none">Nenhuma</string>
   <!--Name of the swipe action to select/deselect a message-->
+  <string name="general_settings_swipe_action_toggle_selection">Seleção alternada</string>
   <!--Name of the swipe action to mark as message as read/unread-->
   <string name="general_settings_swipe_action_toggle_read">Marcar como lida/não-lida</string>
   <!--Name of the swipe action to add/remove a star-->
+  <string name="general_settings_swipe_action_toggle_star">Adicionar/remover estrela</string>
   <!--Name of the swipe action to archive a message-->
   <string name="general_settings_swipe_action_archive">Arquivo</string>
   <!--Name of the swipe action to delete a message-->
@@ -258,7 +266,10 @@
   <!--Name of the swipe action to move a message to another folder-->
   <string name="general_settings_swipe_action_move">Mover</string>
   <!--Title of the setting to specify the density of the message list-->
+  <string name="general_settings_message_list_density_title">Densidade</string>
+  <string name="general_settings_ui_density_compact">Compacto</string>
   <string name="general_settings_ui_density_default">Predefinição</string>
+  <string name="general_settings_ui_density_relaxed">Relaxado</string>
   <string name="global_settings_privacy_hide_useragent">Ocultar cliente de email</string>
   <string name="global_settings_privacy_hide_useragent_detail">Remove Mail User-Agent from mail headers</string>
   <string name="global_settings_privacy_hide_timezone">Ocultar fuso horário</string>
@@ -329,6 +340,7 @@
   <string name="account_setup_incoming_delete_policy_delete_label">Eliminar no servidor</string>
   <string name="account_setup_incoming_delete_policy_markread_label">Marcar como lido no servidor</string>
   <string name="account_setup_incoming_use_compression">Usar compressão</string>
+  <string name="account_setup_incoming_send_client_id">Enviar ID do client</string>
   <string name="account_setup_expunge_policy_label">Apagar mensagens eliminadas no servidor</string>
   <string name="account_setup_expunge_policy_immediately">Imediatamente</string>
   <string name="account_setup_expunge_policy_on_poll">Na verificação</string>
@@ -534,6 +546,7 @@
   <string name="folder_settings_folder_push_mode_normal">Sem Classe</string>
   <string name="folder_settings_folder_push_mode_first_class">1ª classe</string>
   <string name="folder_settings_folder_push_mode_second_class">2ª classe</string>
+  <string name="folder_settings_folder_push_mode_inherited">Igual à classe de sondagem</string>
   <string name="folder_settings_folder_notify_mode_label">Classe de notificação da pasta</string>
   <string name="folder_settings_folder_notify_mode_normal">Sem Classe</string>
   <string name="folder_settings_folder_notify_mode_first_class">1ª classe</string>
@@ -676,6 +689,7 @@
   <string name="animations_summary">Usar efeitos visuais exuberantes</string>
   <string name="volume_navigation_title">Navegação com os botões de volume na visualização de mensagens</string>
   <string name="show_unified_inbox_title">Mostrar caixa de entrada unificada</string>
+  <string name="show_starred_count_title">Mostrar contagem de estrelas</string>
   <string name="integrated_inbox_title">Caixa de entrada unificada</string>
   <string name="integrated_inbox_detail">Todas as mensagens em pastas unificadas</string>
   <string name="folder_settings_include_in_integrated_inbox_label">Unificar</string>
@@ -697,6 +711,7 @@
   <!--Displayed in the font size settings screen to configure the font size of the account name in the message view.-->
   <string name="font_size_message_view_account">Nome da conta</string>
   <string name="font_size_message_view_sender">Remetente</string>
+  <string name="font_size_message_view_recipients">Destinatários</string>
   <string name="font_size_message_view_subject">Assunto</string>
   <string name="font_size_message_view_date">Data e hora</string>
   <string name="font_size_message_view_content">Corpo da mensagem</string>
@@ -1053,10 +1068,15 @@ Pode manter esta mensagem e usá-la como uma cópia de segurança para a sua cha
   <!--Name of the swipe action to move a message. The ellipsis (…) indicates that there is another step (selecting a folder) before the action is performed. Try to keep it short.-->
   <string name="swipe_action_move">Mover…</string>
   <!--Name of setting to configure whether to show a "compose" floating action button on top of the message list-->
+  <string name="general_settings_show_compose_button_title">Mostrar botão de composição flutuante</string>
   <!--Displayed in the toolbar when there was an error loading the message list, e.g. because the folder no longer exists.-->
+  <string name="message_list_error_title">Erro</string>
   <!--Displayed instead of the message list when a folder couldn't be found, e.g. due to an outdated home screen shortcut.-->
+  <string name="message_list_error_folder_not_found">Pasta não encontrada</string>
   <!--Title of the toolbar that is displayed when the message details bottom sheet has been expanded-->
+  <string name="message_details_toolbar_title">Detalhes da mensagem</string>
   <!--Displayed when an email is missing the 'Date' header field and no date can be displayed in the message details bottom sheet.-->
+  <string name="message_details_missing_date">Cabeçalho \"Data\" em falta</string>
   <!--Title of the "From" section in the message details bottom sheet. This should probably be the same as the string 'recipient_from'.-->
   <string name="message_details_from_section_title">De</string>
   <!--Title of the "Sender" section in the message details bottom sheet. This refers to the 'Sender' header. Be careful with translations.-->
@@ -1070,11 +1090,18 @@ Pode manter esta mensagem e usá-la como uma cópia de segurança para a sua cha
   <!--Title of the "Bcc" section in the message details bottom sheet. This should probably be the same as the string 'recipient_bcc'.-->
   <string name="message_details_bcc_section_title">Bcc</string>
   <!--Displayed when loading the message details has failed-->
+  <string name="message_details_loading_error">Ocorreu um erro ao carregar os detalhes da mensagem.</string>
   <!--Name of the action to add a person to contacts. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+  <string name="action_add_to_contacts">Adicionar aos contactos</string>
   <!--Name of the action to compose a new message to a particular address. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+  <string name="action_compose_message_to">Compor mensagem para</string>
   <!--Name of the action to copy an email address to the clipboard. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+  <string name="action_copy_email_address">Copiar o endereço de email</string>
   <!--Name of the action to copy a name and email address to the clipboard. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+  <string name="action_copy_name_and_email_address">Copiar o nome e o endereço de email</string>
   <!--A user visible label for the email address copied to the clipboard-->
   <string name="clipboard_label_email_address">Endereço de email</string>
   <!--A user visible label for the name and email address copied to the clipboard-->
+  <string name="clipboard_label_name_and_email_address">Nome e endereço de email</string>
+  <!--Might be displayed in a notification when deleting an account (in the background)-->
 </resources>
diff --git a/app/ui/legacy/src/main/res/values-ro/strings.xml b/app/ui/legacy/src/main/res/values-ro/strings.xml
index c8e801ce85ad74350b1b5d8d33ff645b46c622b9..10ccf2d07a7e62a3e28ddd07df015281eab35fe5 100644
--- a/app/ui/legacy/src/main/res/values-ro/strings.xml
+++ b/app/ui/legacy/src/main/res/values-ro/strings.xml
@@ -1098,4 +1098,5 @@ Poți păstra acest mesaj și să îl folosești drept copie de siguranță a ch
     <string name="clipboard_label_email_address">Adresa e-mail</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
     <string name="clipboard_label_name_and_email_address">Numele și adresa de e-mail</string>
-</resources>
\ No newline at end of file
+  <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-ru/strings.xml b/app/ui/legacy/src/main/res/values-ru/strings.xml
index 71df738ab7f79921aa15db5746c968e867ac69eb..fc412182b5e9599efbdf31edffa81ea74925bc54 100644
--- a/app/ui/legacy/src/main/res/values-ru/strings.xml
+++ b/app/ui/legacy/src/main/res/values-ru/strings.xml
@@ -310,7 +310,6 @@
     <string name="account_setup_incoming_client_certificate_label">Сертификат клиента</string>
     <string name="account_setup_incoming_pop_server_label">Сервер POP3</string>
     <string name="account_setup_incoming_imap_server_label">Сервер IMAP</string>
-    <string name="account_setup_incoming_webdav_server_label">Сервер Exchange</string>
     <string name="account_setup_incoming_port_label">Порт</string>
     <string name="account_setup_incoming_security_label">Безопасность</string>
     <string name="account_setup_incoming_auth_type_label">Аутентификация</string>
@@ -336,9 +335,6 @@
     <string name="spam_folder_label">Папка спам</string>
     <string name="account_setup_incoming_subscribed_folders_only_label">Только подписанные папки</string>
     <string name="account_setup_auto_expand_folder">Автопереход в папку</string>
-    <string name="account_setup_incoming_webdav_path_prefix_label">Путь OWA</string>
-    <string name="account_setup_incoming_webdav_auth_path_label">Путь аутентификации</string>
-    <string name="account_setup_incoming_webdav_mailbox_path_label">Псевдоним ящика</string>
     <string name="account_setup_outgoing_title">Сервер исходящей почты</string>
     <string name="account_setup_outgoing_smtp_server_label">Сервер SMTP</string>
     <string name="account_setup_outgoing_port_label">Порт</string>
@@ -1108,4 +1104,17 @@
     <string name="message_view_additional_recipient_prefix">+</string>
     <string name="message_view_recipient_prefix">"в "</string>
     <string name="welcome_message_text">Создайте новую учетную запись или импортируйте учетные записи электронной почты из предыдущего файла настроек.</string>
+    <!--Button text of the "snack bar" that is displayed when the app was updated.-->
+    <string name="changelog_snackbar_button_text">Показать</string>
+    <!--Title of the setting to specify the density of the message list-->
+    <string name="general_settings_message_list_density_title">Плотность</string>
+    <string name="general_settings_ui_density_compact">Компактная</string>
+    <string name="general_settings_ui_density_default">По умолчанию</string>
+    <string name="general_settings_ui_density_relaxed">Ослабленная</string>
+    <string name="account_setup_incoming_send_client_id">Отправить client ID</string>
+    <!--Displayed in the font size settings screen to configure the font size of the account name in the message view.-->
+    <string name="font_size_message_view_account">Название учётной записи</string>
+    <!--Name of the action to compose a new message to a particular address. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+    <string name="action_compose_message_to">Написать письмо</string>
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
 </resources>
diff --git a/app/ui/legacy/src/main/res/values-sk/strings.xml b/app/ui/legacy/src/main/res/values-sk/strings.xml
index c534086e5a3336b69e1d77f367a51418a736ca00..305bc613ec527c13b4a6255639fa5f29fd835799 100644
--- a/app/ui/legacy/src/main/res/values-sk/strings.xml
+++ b/app/ui/legacy/src/main/res/values-sk/strings.xml
@@ -899,4 +899,5 @@
     <!--A user visible label for the email address copied to the clipboard-->
     <string name="clipboard_label_email_address">E-mailová adresa</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
-</resources>
\ No newline at end of file
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-sl/strings.xml b/app/ui/legacy/src/main/res/values-sl/strings.xml
index 0af544557554905b72a29733a15e243bc4720e0c..56c77da0db9d3092435f8538c6c245a283e551cf 100644
--- a/app/ui/legacy/src/main/res/values-sl/strings.xml
+++ b/app/ui/legacy/src/main/res/values-sl/strings.xml
@@ -1103,4 +1103,5 @@ Sporočilo lahko shranite in ga uporabite kot varno kopijo šifrirnega ključa.
     <string name="clipboard_label_email_address">Naslov elektronske pošte</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
     <string name="clipboard_label_name_and_email_address">Ime in e-poštni naslov</string>
-</resources>
\ No newline at end of file
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-sq/strings.xml b/app/ui/legacy/src/main/res/values-sq/strings.xml
index e6c51b951f631b5c5dacfe0c1107692098ad7600..7f359058823f4767831bdd7f01cfb361932b3ca5 100644
--- a/app/ui/legacy/src/main/res/values-sq/strings.xml
+++ b/app/ui/legacy/src/main/res/values-sq/strings.xml
@@ -1094,4 +1094,5 @@ Mund ta mbani këtë mesazh dhe ta përdorni si një kopjeruatje të kyçit tuaj
     <string name="clipboard_label_email_address">Adresë email</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
     <string name="clipboard_label_name_and_email_address">Emër dhe adresë email</string>
-</resources>
\ No newline at end of file
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-sr/strings.xml b/app/ui/legacy/src/main/res/values-sr/strings.xml
index 209f474234f86f1722ef3e51141a8e524cfcc47f..cb655cc58657dbbc34d7020d3daf092f28d103bb 100644
--- a/app/ui/legacy/src/main/res/values-sr/strings.xml
+++ b/app/ui/legacy/src/main/res/values-sr/strings.xml
@@ -995,4 +995,5 @@
     <!--A user visible label for the email address copied to the clipboard-->
     <string name="clipboard_label_email_address">Адреса е-поште</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
-</resources>
\ No newline at end of file
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-sv/strings.xml b/app/ui/legacy/src/main/res/values-sv/strings.xml
index fc19e5745ec2bf93a9be268fc4ba0c2eb3fca6d7..58bb50c47eab3c211d2657576f8f1eee3955ec3a 100644
--- a/app/ui/legacy/src/main/res/values-sv/strings.xml
+++ b/app/ui/legacy/src/main/res/values-sv/strings.xml
@@ -1105,4 +1105,5 @@ Du kan behålla detta meddelande och använda det som en säkerhetskopia för di
     <string name="openpgp_setup_encryption_key_description">Helvägskryptering är det säkraste sättet att hålla andra människor från att spionera på kommunikationen eller få åtkomst till skickad data mellan en enhet till en annan.
 \n
 \nFör att skicka ett krypterat e-postmeddelande krävs ett nyckelpar så att data krypterad på avsändarens enhet kan avkrypteras av den avsedda mottagaren. Till exempel behöver du den publika nyckeln från den person du skickar till och samma gäller det omvända.</string>
-</resources>
\ No newline at end of file
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-tr/strings.xml b/app/ui/legacy/src/main/res/values-tr/strings.xml
index 24f20618f344b8096ad9187a7103460abf8333f5..b72fa84c3b4d5fa30e2af6a7713961c7f0af41a3 100644
--- a/app/ui/legacy/src/main/res/values-tr/strings.xml
+++ b/app/ui/legacy/src/main/res/values-tr/strings.xml
@@ -1059,4 +1059,5 @@ Bu iletiyi saklayabilir ve gizli anahtarınız için bir yedekleme olarak kullan
     <!--A user visible label for the email address copied to the clipboard-->
     <string name="clipboard_label_email_address">E-posta adresi</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
-</resources>
\ No newline at end of file
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-uk/strings.xml b/app/ui/legacy/src/main/res/values-uk/strings.xml
index 3292b529dccd8ce313fa4d4c9fff35d24a4d82b7..998cdc2ff090114c3c19c65f55bd705c77faf1ed 100644
--- a/app/ui/legacy/src/main/res/values-uk/strings.xml
+++ b/app/ui/legacy/src/main/res/values-uk/strings.xml
@@ -1024,6 +1024,21 @@
 
 Ви можете зберегти це повідомлення і використовувати його як резервну копію вашого секретного ключа. Якщо ви хочете це зробити, запишіть пароль і збережіть його у надійному місці.
 </string>
+    <!--Button text of the "snack bar" that is displayed when the app was updated.-->
+    <string name="changelog_snackbar_button_text">Показати</string>
+    <!--Displayed in the message view screen in front of the recipient list. For most languages this should end with a space.-->
+    <string name="message_view_recipient_prefix">"для "</string>
+    <!--Displayed in the message view screen in front of the number of additional recipients (the ones that are not displayed).-->
+    <string name="message_view_additional_recipient_prefix">+</string>
+    <!--Displayed in the message view screen if the message was addressed to the user. Make sure this works with 'message_view_recipient_prefix'. In English it's "to me".-->
+    <string name="message_view_me_text">мене</string>
+    <!--Text of the button that is displayed below the message header when the message body references one or more remote images-->
+    <string name="message_view_show_remote_images_action">Показати зображення</string>
+    <!--Title of the setting to specify the density of the message list-->
+    <string name="general_settings_message_list_density_title">Щільність</string>
+    <string name="general_settings_ui_density_compact">Компактна</string>
+    <string name="general_settings_ui_density_relaxed">Розслаблена</string>
+    <string name="account_setup_incoming_send_client_id">Надіслати ID клієнта</string>
     <string name="ac_transfer_error_send">При надсиланні повідомлення сталася помилка. Перевірте підключення до мережі та налаштування вихідного сервера.</string>
     <string name="switch_on">Увімкнено</string>
     <string name="switch_off">Вимкнено</string>
@@ -1088,4 +1103,27 @@
     <!--A user visible label for the email address copied to the clipboard-->
     <string name="clipboard_label_email_address">Електронна адреса</string>
     <!--A user visible label for the name and email address copied to the clipboard-->
-</resources>
\ No newline at end of file
+    <!--Name of setting to configure whether to show a "compose" floating action button on top of the message list-->
+    <string name="general_settings_show_compose_button_title">Показати плаваючу кнопку створення повідомлення</string>
+    <!--Displayed in the toolbar when there was an error loading the message list, e.g. because the folder no longer exists.-->
+    <string name="message_list_error_title">Помилка</string>
+    <!--Displayed instead of the message list when a folder couldn't be found, e.g. due to an outdated home screen shortcut.-->
+    <string name="message_list_error_folder_not_found">Папка не знайдена</string>
+    <!--Title of the toolbar that is displayed when the message details bottom sheet has been expanded-->
+    <string name="message_details_toolbar_title">Деталі повідомлення</string>
+    <!--Displayed when an email is missing the 'Date' header field and no date can be displayed in the message details bottom sheet.-->
+    <string name="message_details_missing_date">Відсутній заголовок \'Дата\'</string>
+    <!--Displayed when loading the message details has failed-->
+    <string name="message_details_loading_error">Виникла помилка під час завантаження деталей повідомлення.</string>
+    <!--Name of the action to add a person to contacts. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+    <string name="action_add_to_contacts">Додати до контактів</string>
+    <!--Name of the action to compose a new message to a particular address. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+    <string name="action_compose_message_to">Написати лист</string>
+    <!--Name of the action to copy an email address to the clipboard. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+    <string name="action_copy_email_address">Скопіювати адресу ел. пошти</string>
+    <!--Name of the action to copy a name and email address to the clipboard. Usually displayed in a menu or in a tooltip when long-pressing the associated icon.-->
+    <string name="action_copy_name_and_email_address">Скопіювати ім\'я та адресу ел. пошти</string>
+    <!--A user visible label for the name and email address copied to the clipboard-->
+    <string name="clipboard_label_name_and_email_address">Ім\'я та адреса ел. пошти</string>
+    <!--Might be displayed in a notification when deleting an account (in the background)-->
+</resources>
diff --git a/app/ui/legacy/src/main/res/values-zh-rCN/strings.xml b/app/ui/legacy/src/main/res/values-zh-rCN/strings.xml
index 5d254a20eff545bfe246c70b5d494640a0947971..8e88f1545ad55674d14e50238ac77ad8c4273e27 100644
--- a/app/ui/legacy/src/main/res/values-zh-rCN/strings.xml
+++ b/app/ui/legacy/src/main/res/values-zh-rCN/strings.xml
@@ -1088,4 +1088,5 @@
   <string name="clipboard_label_email_address">邮件地址</string>
   <!--A user visible label for the name and email address copied to the clipboard-->
   <string name="clipboard_label_name_and_email_address">姓名和电子邮箱地址</string>
+  <!--Might be displayed in a notification when deleting an account (in the background)-->
 </resources>
diff --git a/app/ui/legacy/src/main/res/values-zh-rTW/strings.xml b/app/ui/legacy/src/main/res/values-zh-rTW/strings.xml
index 1cf00686ce5c0d6b337c920ba9adc7657364470b..1695bd19fb49f0d91429fd8a17088b226e49e64a 100644
--- a/app/ui/legacy/src/main/res/values-zh-rTW/strings.xml
+++ b/app/ui/legacy/src/main/res/values-zh-rTW/strings.xml
@@ -330,6 +330,7 @@
   <string name="account_setup_incoming_delete_policy_delete_label">立刻從伺服器上刪除</string>
   <string name="account_setup_incoming_delete_policy_markread_label">在伺服器上將郵件標記為已讀</string>
   <string name="account_setup_incoming_use_compression">使用壓縮</string>
+  <string name="account_setup_incoming_send_client_id">傳送客戶端 ID</string>
   <string name="account_setup_expunge_policy_label">抹除刪除的郵件</string>
   <string name="account_setup_expunge_policy_immediately">立刻</string>
   <string name="account_setup_expunge_policy_on_poll">接收郵件時</string>
@@ -1077,4 +1078,5 @@
   <string name="clipboard_label_email_address">電子郵件地址</string>
   <!--A user visible label for the name and email address copied to the clipboard-->
   <string name="clipboard_label_name_and_email_address">姓名和電子郵件地址</string>
+  <!--Might be displayed in a notification when deleting an account (in the background)-->
 </resources>
diff --git a/app/ui/legacy/src/main/res/values/dimensions.xml b/app/ui/legacy/src/main/res/values/dimensions.xml
index eef9742adb06368d889cf34092368d16cd18192c..e282e4792b7e8c409229ec8d4ba89ac9e77e2010 100644
--- a/app/ui/legacy/src/main/res/values/dimensions.xml
+++ b/app/ui/legacy/src/main/res/values/dimensions.xml
@@ -43,4 +43,12 @@
     <!-- This padding is calculated from unread_message_indicator-->
     <!-- Equals size of the dot (10dp) + left margin (12dp) + right margin (13dp) -->
     <dimen name="messageListItemStartPadding">34dp</dimen>
+
+    <dimen name="appTextSizeTiniest" format="dimension">10sp</dimen>
+    <dimen name="appTextSizeTiny" format="dimension">12sp</dimen>
+    <dimen name="appTextSizeSmaller" format="dimension">14sp</dimen>
+    <dimen name="appTextSizeSmall" format="dimension">16sp</dimen>
+    <dimen name="appTextSizeMedium" format="dimension">18sp</dimen>
+    <dimen name="appTextSizeLarge" format="dimension">20sp</dimen>
+    <dimen name="appTextSizeLarger" format="dimension">22sp</dimen>
 </resources>
diff --git a/app/ui/legacy/src/main/res/values/strings.xml b/app/ui/legacy/src/main/res/values/strings.xml
index 9a4cb3ac71fe4938d64c112a3c6fb817461b8b51..2e4cb4ae547265dba391edc00d9961f065f9ee77 100644
--- a/app/ui/legacy/src/main/res/values/strings.xml
+++ b/app/ui/legacy/src/main/res/values/strings.xml
@@ -1138,4 +1138,10 @@ You can keep this message and use it as a backup for your secret key. If you wan
     <string name="clipboard_label_email_address">Email address</string>
     <!-- A user visible label for the name and email address copied to the clipboard -->
     <string name="clipboard_label_name_and_email_address">Name and email address</string>
+
+    <!-- Might be displayed in a notification when deleting an account (in the background) -->
+    <string name="background_work_notification_remove_account">Removing account…</string>
+
+    <!-- For unread messages the first line of a message list item is modified by this to improve the experience for people with screen readers. -->
+    <string name="message_list_content_description_unread_prefix">unread, %s</string>
 </resources>
diff --git a/app/ui/legacy/src/main/res/xml/account_settings.xml b/app/ui/legacy/src/main/res/xml/account_settings.xml
index 5214b7bcf77c0da76d54c5bea330db40bcc52668..8542acf14c85f45d130a57948c062d91d6bc6ce1 100644
--- a/app/ui/legacy/src/main/res/xml/account_settings.xml
+++ b/app/ui/legacy/src/main/res/xml/account_settings.xml
@@ -283,6 +283,11 @@
             app:useSimpleSummaryProvider="true"
             android:title="@string/account_settings_folder_display_mode_label" />
 
+        <CheckBoxPreference
+            android:layout="@layout/custom_preference"
+            android:key="subscribed_folders_only"
+            android:title="@string/account_setup_incoming_subscribed_folders_only_label" />
+
         <ListPreference
             android:layout="@layout/custom_preference"
             android:dialogTitle="@string/account_settings_folder_target_mode_label"
diff --git a/app/ui/legacy/src/test/java/com/fsck/k9/account/AccountCreatorTest.java b/app/ui/legacy/src/test/java/com/fsck/k9/account/AccountCreatorTest.java
index b8776bccc6aed22585f2271443501ea1ff6bc020..dc429e1299884c195ee0e0e22de5a403720e0ff2 100644
--- a/app/ui/legacy/src/test/java/com/fsck/k9/account/AccountCreatorTest.java
+++ b/app/ui/legacy/src/test/java/com/fsck/k9/account/AccountCreatorTest.java
@@ -7,7 +7,7 @@ import com.fsck.k9.Account.DeletePolicy;
 import com.fsck.k9.Preferences;
 import com.fsck.k9.RobolectricTest;
 import com.fsck.k9.mail.ConnectionSecurity;
-import com.fsck.k9.preferences.Protocols;
+import app.k9mail.core.common.mail.Protocols;
 
 import org.junit.Before;
 import org.junit.Test;
@@ -17,51 +17,51 @@ import static org.mockito.Mockito.mock;
 
 
 public class AccountCreatorTest extends RobolectricTest {
-    private AccountCreator accountCreator;
+    private AccountCreatorHelper accountCreatorHelper;
 
     @Before
     public void setUp() {
         Preferences preferences = mock(Preferences.class);
         Resources resources = mock(Resources.class);
-        accountCreator = new AccountCreator(preferences, resources);
+        accountCreatorHelper = new AccountCreatorHelper(preferences, resources);
     }
 
     @Test
     public void getDefaultDeletePolicy_withImap_shouldReturn_ON_DELETE() {
-        DeletePolicy result = accountCreator.getDefaultDeletePolicy(Protocols.IMAP);
+        DeletePolicy result = accountCreatorHelper.getDefaultDeletePolicy(Protocols.IMAP);
 
         assertEquals(DeletePolicy.ON_DELETE, result);
     }
 
     @Test
     public void getDefaultDeletePolicy_withPop3_shouldReturn_NEVER() {
-        DeletePolicy result = accountCreator.getDefaultDeletePolicy(Protocols.POP3);
+        DeletePolicy result = accountCreatorHelper.getDefaultDeletePolicy(Protocols.POP3);
 
         assertEquals(DeletePolicy.NEVER, result);
     }
 
     @Test(expected = AssertionError.class)
     public void getDefaultDeletePolicy_withSmtp_shouldFail() {
-        accountCreator.getDefaultDeletePolicy(Protocols.SMTP);
+        accountCreatorHelper.getDefaultDeletePolicy(Protocols.SMTP);
     }
 
     @Test
     public void getDefaultPort_withNoConnectionSecurityAndImap_shouldReturnDefaultPort() {
-        int result = accountCreator.getDefaultPort(ConnectionSecurity.NONE, Protocols.IMAP);
+        int result = accountCreatorHelper.getDefaultPort(ConnectionSecurity.NONE, Protocols.IMAP);
 
         assertEquals(143, result);
     }
 
     @Test
     public void getDefaultPort_withStartTlsAndImap_shouldReturnDefaultPort() {
-        int result = accountCreator.getDefaultPort(ConnectionSecurity.STARTTLS_REQUIRED, Protocols.IMAP);
+        int result = accountCreatorHelper.getDefaultPort(ConnectionSecurity.STARTTLS_REQUIRED, Protocols.IMAP);
 
         assertEquals(143, result);
     }
 
     @Test
     public void getDefaultPort_withTlsAndImap_shouldReturnDefaultTlsPort() {
-        int result = accountCreator.getDefaultPort(ConnectionSecurity.SSL_TLS_REQUIRED, Protocols.IMAP);
+        int result = accountCreatorHelper.getDefaultPort(ConnectionSecurity.SSL_TLS_REQUIRED, Protocols.IMAP);
 
         assertEquals(993, result);
     }
diff --git a/app/ui/legacy/src/test/java/com/fsck/k9/activity/compose/RecipientLoaderTest.java b/app/ui/legacy/src/test/java/com/fsck/k9/activity/compose/RecipientLoaderTest.java
index 6d989455222af3f5161073fbd642e111f201626d..c16e444c89cd81222d9b2b6c78a6fbbcbe7614a9 100644
--- a/app/ui/legacy/src/test/java/com/fsck/k9/activity/compose/RecipientLoaderTest.java
+++ b/app/ui/legacy/src/test/java/com/fsck/k9/activity/compose/RecipientLoaderTest.java
@@ -49,8 +49,7 @@ public class RecipientLoaderTest extends RobolectricTest {
             ContactsContract.Contacts.STARRED
     };
     static final String[] PROJECTION_NICKNAME = {
-            ContactsContract.Data.CONTACT_ID,
-            ContactsContract.CommonDataKinds.Nickname.NAME
+            ContactsContract.Data.CONTACT_ID
     };
     static final String[] PROJECTION_CRYPTO_ADDRESSES = { "address", "uid_address" };
     static final String[] PROJECTION_CRYPTO_STATUS = { "address", "uid_key_status", "autocrypt_key_status" };
@@ -66,7 +65,7 @@ public class RecipientLoaderTest extends RobolectricTest {
     static final String[] CONTACT_WITH_NICKNAME_NOT_CONTACTED =
             new String[] { "0", "Eve_notContacted", "eve_notContacted", "eve_notContacted@host.com", TYPE, null, "2",
                     null, "0", "Eve", "0" };
-    static final String[] NICKNAME_NOT_CONTACTED = new String[] { "2", "Eves_Nickname_Bob" };
+    static final String[] NICKNAME_NOT_CONTACTED = new String[] { "2" };
 
     static final String QUERYSTRING = "querystring";
 
diff --git a/app/ui/legacy/src/test/java/com/fsck/k9/activity/compose/ReplyToPresenterTest.kt b/app/ui/legacy/src/test/java/com/fsck/k9/activity/compose/ReplyToPresenterTest.kt
index 69c420263c47450ba6d00b7e6675e195ffb896b8..df06ad24135d778982a3b478e833f1eec5a50e28 100644
--- a/app/ui/legacy/src/test/java/com/fsck/k9/activity/compose/ReplyToPresenterTest.kt
+++ b/app/ui/legacy/src/test/java/com/fsck/k9/activity/compose/ReplyToPresenterTest.kt
@@ -1,12 +1,12 @@
 package com.fsck.k9.activity.compose
 
 import android.os.Bundle
+import app.k9mail.core.android.testing.RobolectricTest
 import assertk.assertThat
 import assertk.assertions.isFalse
 import assertk.assertions.isSameAs
 import assertk.assertions.isTrue
 import com.fsck.k9.Identity
-import com.fsck.k9.RobolectricTest
 import com.fsck.k9.mail.Address
 import org.junit.Test
 import org.mockito.kotlin.doReturn
diff --git a/app/ui/legacy/src/test/java/com/fsck/k9/contacts/ContactLetterExtractorTest.kt b/app/ui/legacy/src/test/java/com/fsck/k9/contacts/ContactLetterExtractorTest.kt
index cc793c47fe53f58eabd90d2d49a4ec1260abffe1..1aa20baa8e8914ce089a764f03728241d6c29c23 100644
--- a/app/ui/legacy/src/test/java/com/fsck/k9/contacts/ContactLetterExtractorTest.kt
+++ b/app/ui/legacy/src/test/java/com/fsck/k9/contacts/ContactLetterExtractorTest.kt
@@ -1,8 +1,9 @@
 package com.fsck.k9.contacts
 
-import com.fsck.k9.RobolectricTest
+import app.k9mail.core.android.testing.RobolectricTest
+import assertk.assertThat
+import assertk.assertions.isEqualTo
 import com.fsck.k9.mail.Address
-import org.junit.Assert.assertEquals
 import org.junit.Test
 
 class ContactLetterExtractorTest : RobolectricTest() {
@@ -54,6 +55,6 @@ class ContactLetterExtractorTest : RobolectricTest() {
     }
 
     private fun assertExtractedLetterEquals(expected: String, address: String) {
-        assertEquals(expected, letterExtractor.extractContactLetter(Address(address)))
+        assertThat(letterExtractor.extractContactLetter(Address(address))).isEqualTo(expected)
     }
 }
diff --git a/app/ui/legacy/src/test/java/com/fsck/k9/message/PgpMessageBuilderTest.kt b/app/ui/legacy/src/test/java/com/fsck/k9/message/PgpMessageBuilderTest.kt
index c538956d11fd1fca5bbcac7895ab11ed0a98260f..3e26b9f3e8db1cb51573663690b8fa107ba26ce6 100644
--- a/app/ui/legacy/src/test/java/com/fsck/k9/message/PgpMessageBuilderTest.kt
+++ b/app/ui/legacy/src/test/java/com/fsck/k9/message/PgpMessageBuilderTest.kt
@@ -4,6 +4,17 @@ import android.app.Activity
 import android.app.PendingIntent
 import android.content.Intent
 import android.os.Parcelable
+import assertk.Assert
+import assertk.all
+import assertk.assertThat
+import assertk.assertions.containsExactly
+import assertk.assertions.hasSize
+import assertk.assertions.isEmpty
+import assertk.assertions.isEqualTo
+import assertk.assertions.isInstanceOf
+import assertk.assertions.isNotNull
+import assertk.assertions.isNull
+import assertk.assertions.isSameAs
 import com.fsck.k9.Account.QuoteStyle
 import com.fsck.k9.CoreResourceProvider
 import com.fsck.k9.Identity
@@ -15,29 +26,29 @@ import com.fsck.k9.autocrypt.AutocryptOpenPgpApiInteractor
 import com.fsck.k9.autocrypt.AutocryptOperations
 import com.fsck.k9.autocrypt.AutocryptOperationsHelper.assertMessageHasAutocryptHeader
 import com.fsck.k9.mail.Address
-import com.fsck.k9.mail.BodyPart
 import com.fsck.k9.mail.BoundaryGenerator
 import com.fsck.k9.mail.MessagingException
+import com.fsck.k9.mail.assertk.asBytes
+import com.fsck.k9.mail.assertk.asText
+import com.fsck.k9.mail.assertk.body
+import com.fsck.k9.mail.assertk.bodyPart
+import com.fsck.k9.mail.assertk.bodyParts
+import com.fsck.k9.mail.assertk.contentTransferEncoding
+import com.fsck.k9.mail.assertk.contentType
+import com.fsck.k9.mail.assertk.mimeType
+import com.fsck.k9.mail.assertk.parameter
+import com.fsck.k9.mail.assertk.value
 import com.fsck.k9.mail.internet.BinaryTempFileBody
 import com.fsck.k9.mail.internet.MessageIdGenerator
 import com.fsck.k9.mail.internet.MimeMessage
 import com.fsck.k9.mail.internet.MimeMultipart
-import com.fsck.k9.mail.internet.MimeUtility
 import com.fsck.k9.mail.internet.TextBody
 import com.fsck.k9.message.MessageBuilder.Callback
 import com.fsck.k9.message.quote.InsertableHtmlContent
 import com.fsck.k9.view.RecipientSelectView
-import java.io.ByteArrayOutputStream
-import java.io.IOException
 import java.io.OutputStream
 import java.util.Date
-import org.apache.commons.io.Charsets
-import org.apache.commons.io.IOUtils
 import org.apache.james.mime4j.util.MimeUtil
-import org.junit.Assert
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNotNull
-import org.junit.Assert.assertTrue
 import org.junit.Before
 import org.junit.Test
 import org.koin.core.component.inject
@@ -101,7 +112,7 @@ class PgpMessageBuilderTest : K9RobolectricTest() {
         verifyNoMoreInteractions(mockCallback)
 
         val message = captor.value
-        assertEquals("text/plain", message.mimeType)
+        assertThat(message.mimeType).isEqualTo("text/plain")
     }
 
     @Test
@@ -117,7 +128,7 @@ class PgpMessageBuilderTest : K9RobolectricTest() {
 
         val message = captor.value
         assertMessageHasAutocryptHeader(message, SENDER_EMAIL, false, AUTOCRYPT_KEY_MATERIAL)
-        assertEquals(0, message.getHeader("Autocrypt-Draft-State").size)
+        assertThat(message.getHeader("Autocrypt-Draft-State")).isEmpty()
     }
 
     @Test
@@ -164,45 +175,32 @@ class PgpMessageBuilderTest : K9RobolectricTest() {
         val expectedIntent = Intent(OpenPgpApi.ACTION_DETACHED_SIGN)
         expectedIntent.putExtra(OpenPgpApi.EXTRA_SIGN_KEY_ID, TEST_KEY_ID)
         expectedIntent.putExtra(OpenPgpApi.EXTRA_REQUEST_ASCII_ARMOR, true)
-        assertIntentEqualsActionAndExtras(expectedIntent, capturedApiIntent.value)
+        assertThat(capturedApiIntent.value).matches(expectedIntent)
 
         val captor = ArgumentCaptor.forClass(MimeMessage::class.java)
         verify(mockCallback).onMessageBuildSuccess(captor.capture(), eq(false))
         verifyNoMoreInteractions(mockCallback)
 
         val message = captor.value
-        Assert.assertEquals("message must be multipart/signed", "multipart/signed", message.mimeType)
-
-        val multipart = message.body as MimeMultipart
-        Assert.assertEquals("multipart/signed must consist of two parts", 2, multipart.count.toLong())
-
-        val contentBodyPart = multipart.getBodyPart(0)
-        Assert.assertEquals(
-            "first part must have content type text/plain",
-            "text/plain",
-            MimeUtility.getHeaderParameter(contentBodyPart.contentType, null),
-        )
-        assertTrue("signed message body must be TextBody", contentBodyPart.body is TextBody)
-        Assert.assertEquals(MimeUtil.ENC_QUOTED_PRINTABLE, (contentBodyPart.body as TextBody).encoding)
-        assertContentOfBodyPartEquals("content must match the message text", contentBodyPart, TEST_MESSAGE_TEXT)
-
-        val signatureBodyPart = multipart.getBodyPart(1)
-        val contentType = signatureBodyPart.contentType
-        Assert.assertEquals(
-            "second part must be pgp signature",
-            "application/pgp-signature",
-            MimeUtility.getHeaderParameter(contentType, null),
-        )
-        Assert.assertEquals(
-            "second part must be called signature.asc",
-            "signature.asc",
-            MimeUtility.getHeaderParameter(contentType, "name"),
-        )
-        assertContentOfBodyPartEquals(
-            "content must match the supplied detached signature",
-            signatureBodyPart,
-            byteArrayOf(1, 2, 3),
-        )
+        assertThat(message.mimeType).isEqualTo("multipart/signed")
+
+        assertThat(message.body).isInstanceOf<MimeMultipart>().all {
+            bodyParts().hasSize(2)
+            bodyPart(0).all {
+                contentType().value().isEqualTo("text/plain")
+                body().isInstanceOf<TextBody>().all {
+                    contentTransferEncoding().isEqualTo(MimeUtil.ENC_QUOTED_PRINTABLE)
+                    asText().isEqualTo(TEST_MESSAGE_TEXT)
+                }
+            }
+            bodyPart(1).all {
+                contentType().all {
+                    value().isEqualTo("application/pgp-signature")
+                    parameter("name").isEqualTo("signature.asc")
+                }
+                body().asBytes().isEqualTo(byteArrayOf(1, 2, 3))
+            }
+        }
 
         assertMessageHasAutocryptHeader(message, SENDER_EMAIL, false, AUTOCRYPT_KEY_MATERIAL)
     }
@@ -232,7 +230,7 @@ class PgpMessageBuilderTest : K9RobolectricTest() {
         verifyNoMoreInteractions(mockCallback)
 
         val pendingIntent = captor.value
-        Assert.assertSame(pendingIntent, mockPendingIntent)
+        assertThat(pendingIntent).isSameAs(mockPendingIntent)
     }
 
     @Test
@@ -264,7 +262,7 @@ class PgpMessageBuilderTest : K9RobolectricTest() {
             verifyNoMoreInteractions(mockCallback)
 
             returnedRequestCode = rcCaptor.value
-            Assert.assertSame(mockPendingIntent, piCaptor.value)
+            assertThat(piCaptor.value).isEqualTo(mockPendingIntent)
         }
 
         run {
@@ -325,7 +323,7 @@ class PgpMessageBuilderTest : K9RobolectricTest() {
 
         val mimeMessage = buildMessage()
 
-        assertEquals("encrypt=no; ", mimeMessage.getHeader("Autocrypt-Draft-State").get(0))
+        assertThat(mimeMessage.getHeader("Autocrypt-Draft-State")).containsExactly("encrypt=no; ")
     }
 
     @Test
@@ -340,7 +338,8 @@ class PgpMessageBuilderTest : K9RobolectricTest() {
 
         val mimeMessage = buildMessage()
 
-        assertEquals("encrypt=yes; _is-reply-to-encrypted=yes; ", mimeMessage.getHeader("Autocrypt-Draft-State").get(0))
+        assertThat(mimeMessage.getHeader("Autocrypt-Draft-State"))
+            .containsExactly("encrypt=yes; _is-reply-to-encrypted=yes; ")
     }
 
     @Test
@@ -352,7 +351,7 @@ class PgpMessageBuilderTest : K9RobolectricTest() {
 
         val mimeMessage = buildMessage()
 
-        assertEquals("encrypt=yes; _by-choice=yes; ", mimeMessage.getHeader("Autocrypt-Draft-State").get(0))
+        assertThat(mimeMessage.getHeader("Autocrypt-Draft-State")).containsExactly("encrypt=yes; _by-choice=yes; ")
     }
 
     @Test
@@ -364,10 +363,8 @@ class PgpMessageBuilderTest : K9RobolectricTest() {
 
         val mimeMessage = buildMessage()
 
-        assertEquals(
-            "encrypt=no; _sign-only=yes; _by-choice=yes; ",
-            mimeMessage.getHeader("Autocrypt-Draft-State").get(0),
-        )
+        assertThat(mimeMessage.getHeader("Autocrypt-Draft-State"))
+            .containsExactly("encrypt=no; _sign-only=yes; _by-choice=yes; ")
     }
 
     private fun buildMessage(): MimeMessage {
@@ -389,7 +386,7 @@ class PgpMessageBuilderTest : K9RobolectricTest() {
         verify(mockCallback).onMessageBuildSuccess(mimeMessageCaptor.capture(), eq(true))
         verifyNoMoreInteractions(mockCallback)
 
-        assertNotNull(mimeMessageCaptor.value)
+        assertThat(mimeMessageCaptor.value).isNotNull()
         return mimeMessageCaptor.value
     }
 
@@ -510,7 +507,7 @@ class PgpMessageBuilderTest : K9RobolectricTest() {
         expectedApiIntent.putExtra(OpenPgpApi.EXTRA_KEY_IDS, longArrayOf(TEST_KEY_ID))
         expectedApiIntent.putExtra(OpenPgpApi.EXTRA_REQUEST_ASCII_ARMOR, true)
         expectedApiIntent.putExtra(OpenPgpApi.EXTRA_USER_IDS, cryptoStatus.recipientAddressesAsArray)
-        assertIntentEqualsActionAndExtras(expectedApiIntent, capturedApiIntent.value)
+        assertThat(capturedApiIntent.value).matches(expectedApiIntent)
 
         val captor = ArgumentCaptor.forClass(MimeMessage::class.java)
         verify(mockCallback).onMessageBuildSuccess(captor.capture(), eq(false))
@@ -518,34 +515,24 @@ class PgpMessageBuilderTest : K9RobolectricTest() {
 
         val message = captor.value
 
-        Assert.assertEquals("message must be multipart/encrypted", "multipart/encrypted", message.mimeType)
-
-        val multipart = message.body as MimeMultipart
-        Assert.assertEquals("multipart/encrypted must consist of two parts", 2, multipart.count.toLong())
-
-        val dummyBodyPart = multipart.getBodyPart(0)
-        Assert.assertEquals(
-            "first part must be pgp encrypted dummy part",
-            "application/pgp-encrypted",
-            dummyBodyPart.contentType,
-        )
-        assertContentOfBodyPartEquals(
-            "content must match the supplied detached signature",
-            dummyBodyPart,
-            "Version: 1",
-        )
-
-        val encryptedBodyPart = multipart.getBodyPart(1)
-        Assert.assertEquals(
-            "second part must be octet-stream of encrypted data",
-            "application/octet-stream; name=\"encrypted.asc\"",
-            encryptedBodyPart.contentType,
-        )
-        assertTrue(
-            "message body must be BinaryTempFileBody",
-            encryptedBodyPart.body is BinaryTempFileBody,
-        )
-        Assert.assertEquals(MimeUtil.ENC_7BIT, (encryptedBodyPart.body as BinaryTempFileBody).encoding)
+        assertThat(message).all {
+            mimeType().isEqualTo("multipart/encrypted")
+            body().isInstanceOf<MimeMultipart>().all {
+                bodyParts().hasSize(2)
+                bodyPart(0).all {
+                    contentType().value().isEqualTo("application/pgp-encrypted")
+                    body().asText().isEqualTo("Version: 1")
+                }
+                bodyPart(1).all {
+                    contentType().all {
+                        value().isEqualTo("application/octet-stream")
+                        parameter("name").isEqualTo("encrypted.asc")
+                    }
+                    body().isInstanceOf<BinaryTempFileBody>()
+                        .contentTransferEncoding().isEqualTo(MimeUtil.ENC_7BIT)
+                }
+            }
+        }
 
         assertMessageHasAutocryptHeader(message, SENDER_EMAIL, false, AUTOCRYPT_KEY_MATERIAL)
     }
@@ -581,16 +568,18 @@ class PgpMessageBuilderTest : K9RobolectricTest() {
         expectedApiIntent.putExtra(OpenPgpApi.EXTRA_KEY_IDS, longArrayOf(TEST_KEY_ID))
         expectedApiIntent.putExtra(OpenPgpApi.EXTRA_REQUEST_ASCII_ARMOR, true)
         expectedApiIntent.putExtra(OpenPgpApi.EXTRA_USER_IDS, cryptoStatus.recipientAddressesAsArray)
-        assertIntentEqualsActionAndExtras(expectedApiIntent, capturedApiIntent.value)
+        assertThat(capturedApiIntent.value).matches(expectedApiIntent)
 
         val captor = ArgumentCaptor.forClass(MimeMessage::class.java)
         verify(mockCallback).onMessageBuildSuccess(captor.capture(), eq(false))
         verifyNoMoreInteractions(mockCallback)
 
         val message = captor.value
-        Assert.assertEquals("text/plain", message.mimeType)
-        assertTrue("message body must be BinaryTempFileBody", message.body is BinaryTempFileBody)
-        Assert.assertEquals(MimeUtil.ENC_7BIT, (message.body as BinaryTempFileBody).encoding)
+        assertThat(message).all {
+            mimeType().isEqualTo("text/plain")
+            body().isInstanceOf<BinaryTempFileBody>()
+                .contentTransferEncoding().isEqualTo(MimeUtil.ENC_7BIT)
+        }
 
         assertMessageHasAutocryptHeader(message, SENDER_EMAIL, false, AUTOCRYPT_KEY_MATERIAL)
     }
@@ -625,14 +614,14 @@ class PgpMessageBuilderTest : K9RobolectricTest() {
         val expectedApiIntent = Intent(OpenPgpApi.ACTION_SIGN)
         expectedApiIntent.putExtra(OpenPgpApi.EXTRA_SIGN_KEY_ID, TEST_KEY_ID)
         expectedApiIntent.putExtra(OpenPgpApi.EXTRA_REQUEST_ASCII_ARMOR, true)
-        assertIntentEqualsActionAndExtras(expectedApiIntent, capturedApiIntent.value)
+        assertThat(capturedApiIntent.value).matches(expectedApiIntent)
 
         val captor = ArgumentCaptor.forClass(MimeMessage::class.java)
         verify(mockCallback).onMessageBuildSuccess(captor.capture(), eq(false))
         verifyNoMoreInteractions(mockCallback)
 
         val message = captor.value
-        Assert.assertEquals("message must be text/plain", "text/plain", message.mimeType)
+        assertThat(message.mimeType).isEqualTo("text/plain")
 
         assertMessageHasAutocryptHeader(message, SENDER_EMAIL, false, AUTOCRYPT_KEY_MATERIAL)
     }
@@ -700,7 +689,7 @@ class PgpMessageBuilderTest : K9RobolectricTest() {
         verifyNoMoreInteractions(mockCallback)
 
         val message = captor.value
-        Assert.assertEquals("text/plain", message.mimeType)
+        assertThat(message.mimeType).isEqualTo("text/plain")
     }
 
     @Test
@@ -778,58 +767,28 @@ class PgpMessageBuilderTest : K9RobolectricTest() {
             return builder
         }
 
-        private fun assertContentOfBodyPartEquals(reason: String, signatureBodyPart: BodyPart, expected: ByteArray) {
-            try {
-                val bos = ByteArrayOutputStream()
-                signatureBodyPart.body.writeTo(bos)
-                Assert.assertArrayEquals(reason, expected, bos.toByteArray())
-            } catch (e: IOException) {
-                Assert.fail()
-            } catch (e: MessagingException) {
-                Assert.fail()
-            }
-        }
-
-        private fun assertContentOfBodyPartEquals(reason: String, signatureBodyPart: BodyPart, expected: String) {
-            try {
-                val bos = ByteArrayOutputStream()
-                val inputStream = MimeUtility.decodeBody(signatureBodyPart.body)
-                IOUtils.copy(inputStream, bos)
-                Assert.assertEquals(reason, expected, String(bos.toByteArray(), Charsets.UTF_8))
-            } catch (e: IOException) {
-                Assert.fail()
-            } catch (e: MessagingException) {
-                Assert.fail()
-            }
-        }
+        private fun Assert<Intent>.matches(expected: Intent) = given { actual ->
+            assertThat(actual.action).isEqualTo(expected.action)
 
-        private fun assertIntentEqualsActionAndExtras(expected: Intent, actual: Intent) {
-            Assert.assertEquals(expected.action, actual.action)
-
-            val expectedExtras = expected.extras
-            val intentExtras = actual.extras
-
-            if (expectedExtras!!.size() != intentExtras!!.size()) {
-                Assert.assertEquals(expectedExtras.size().toLong(), intentExtras.size().toLong())
-            }
+            val expectedExtras = checkNotNull(expected.extras)
+            val intentExtras = checkNotNull(actual.extras)
+            assertThat(intentExtras.size()).isEqualTo(expectedExtras.size())
 
             for (key in expectedExtras.keySet()) {
+                val name = "extra[$key]"
                 val intentExtra = intentExtras.get(key)
                 val expectedExtra = expectedExtras.get(key)
-                if (intentExtra == null) {
-                    if (expectedExtra == null) {
-                        continue
-                    }
-                    Assert.fail("found null for an expected non-null extra: $key")
-                }
-                if (intentExtra is LongArray) {
-                    Assert.assertArrayEquals("error in $key", expectedExtra as LongArray, intentExtra)
-                } else if (intentExtra is Array<*>) {
-                    Assert.assertArrayEquals("error in $key", expectedExtra as Array<*>, intentExtra)
+
+                if (expectedExtra == null) {
+                    assertThat(intentExtra, name).isNull()
                 } else {
-                    if (intentExtra != expectedExtra) {
-                        Assert.assertEquals("error in $key", expectedExtra, intentExtra)
-                    }
+                    assertThat(intentExtra, name).isNotNull()
+                }
+
+                when (intentExtra) {
+                    is LongArray -> assertThat(intentExtra, name).isEqualTo(expectedExtra as LongArray)
+                    is Array<*> -> assertThat(intentExtra as Array<Any?>, name).isEqualTo(expectedExtra as Array<Any?>)
+                    else -> assertThat(intentExtra, name).isEqualTo(expectedExtra)
                 }
             }
         }
diff --git a/app/ui/legacy/src/test/java/com/fsck/k9/ui/helper/RelativeDateTimeFormatterTest.kt b/app/ui/legacy/src/test/java/com/fsck/k9/ui/helper/RelativeDateTimeFormatterTest.kt
index f281d902e1c185f9bfb3464c19af626af16bdc13..d7cf72f7d056aeacfc81085590ab587515e3b8cd 100644
--- a/app/ui/legacy/src/test/java/com/fsck/k9/ui/helper/RelativeDateTimeFormatterTest.kt
+++ b/app/ui/legacy/src/test/java/com/fsck/k9/ui/helper/RelativeDateTimeFormatterTest.kt
@@ -2,14 +2,15 @@ package com.fsck.k9.ui.helper
 
 import android.os.Build
 import android.os.SystemClock
+import app.k9mail.core.android.testing.RobolectricTest
 import app.k9mail.core.testing.TestClock
-import com.fsck.k9.RobolectricTest
+import assertk.assertThat
+import assertk.assertions.isEqualTo
 import java.time.LocalDate
 import java.time.LocalDateTime
 import java.time.ZoneId
 import java.util.TimeZone
 import kotlinx.datetime.Instant
-import org.junit.Assert.assertEquals
 import org.junit.Before
 import org.junit.Test
 import org.robolectric.RuntimeEnvironment
@@ -39,7 +40,7 @@ class RelativeDateTimeFormatterTest : RobolectricTest() {
 
         val displayDate = dateTimeFormatter.formatDate(date)
 
-        assertEquals("May 18", displayDate)
+        assertThat(displayDate).isEqualTo("May 18")
     }
 
     @Test
@@ -49,7 +50,7 @@ class RelativeDateTimeFormatterTest : RobolectricTest() {
 
         val displayDate = dateTimeFormatter.formatDate(date)
 
-        assertEquals("3:41 PM", displayDate)
+        assertThat(displayDate).isEqualTo("3:41 PM")
     }
 
     @Test
@@ -59,7 +60,7 @@ class RelativeDateTimeFormatterTest : RobolectricTest() {
 
         val displayDate = dateTimeFormatter.formatDate(date)
 
-        assertEquals("9:42 AM", displayDate)
+        assertThat(displayDate).isEqualTo("9:42 AM")
     }
 
     @Test
@@ -69,7 +70,7 @@ class RelativeDateTimeFormatterTest : RobolectricTest() {
 
         val displayDate = dateTimeFormatter.formatDate(date)
 
-        assertEquals("Sat", displayDate)
+        assertThat(displayDate).isEqualTo("Sat")
     }
 
     @Test
@@ -79,7 +80,7 @@ class RelativeDateTimeFormatterTest : RobolectricTest() {
 
         val displayDate = dateTimeFormatter.formatDate(date)
 
-        assertEquals("Mon", displayDate)
+        assertThat(displayDate).isEqualTo("Mon")
     }
 
     @Test
@@ -89,7 +90,7 @@ class RelativeDateTimeFormatterTest : RobolectricTest() {
 
         val displayDate = dateTimeFormatter.formatDate(date)
 
-        assertEquals("May 10", displayDate)
+        assertThat(displayDate).isEqualTo("May 10")
     }
 
     @Test
@@ -99,7 +100,7 @@ class RelativeDateTimeFormatterTest : RobolectricTest() {
 
         val displayDate = dateTimeFormatter.formatDate(date)
 
-        assertEquals("May 10", displayDate)
+        assertThat(displayDate).isEqualTo("May 10")
     }
 
     @Test
@@ -109,7 +110,7 @@ class RelativeDateTimeFormatterTest : RobolectricTest() {
 
         val displayDate = dateTimeFormatter.formatDate(date)
 
-        assertEquals("Jan 1", displayDate)
+        assertThat(displayDate).isEqualTo("Jan 1")
     }
 
     @Test
@@ -119,7 +120,7 @@ class RelativeDateTimeFormatterTest : RobolectricTest() {
 
         val displayDate = dateTimeFormatter.formatDate(date)
 
-        assertEquals("12/31/2019", displayDate)
+        assertThat(displayDate).isEqualTo("12/31/2019")
     }
 
     private fun setClockTo(time: String) {
diff --git a/app/ui/legacy/src/test/java/com/fsck/k9/ui/helper/SizeFormatterTest.kt b/app/ui/legacy/src/test/java/com/fsck/k9/ui/helper/SizeFormatterTest.kt
index 9af9595784f15e68d2254bf6a647ea3fd1cf94ac..df4ff353851d387a3620881604e68e805450ad58 100644
--- a/app/ui/legacy/src/test/java/com/fsck/k9/ui/helper/SizeFormatterTest.kt
+++ b/app/ui/legacy/src/test/java/com/fsck/k9/ui/helper/SizeFormatterTest.kt
@@ -1,7 +1,8 @@
 package com.fsck.k9.ui.helper
 
-import com.fsck.k9.RobolectricTest
-import org.junit.Assert.assertEquals
+import app.k9mail.core.android.testing.RobolectricTest
+import assertk.assertThat
+import assertk.assertions.isEqualTo
 import org.junit.Test
 import org.robolectric.RuntimeEnvironment
 import org.robolectric.annotation.Config
@@ -12,46 +13,46 @@ class SizeFormatterTest : RobolectricTest() {
 
     @Test
     fun bytes_lower_bound() {
-        assertEquals("0 B", sizeFormatter.formatSize(0))
+        assertThat(sizeFormatter.formatSize(0)).isEqualTo("0 B")
     }
 
     @Test
     fun bytes_upper_bound() {
-        assertEquals("999 B", sizeFormatter.formatSize(999))
+        assertThat(sizeFormatter.formatSize(999)).isEqualTo("999 B")
     }
 
     @Test
     fun kilobytes_lower_bound() {
-        assertEquals("1.0 kB", sizeFormatter.formatSize(1000))
+        assertThat(sizeFormatter.formatSize(1000)).isEqualTo("1.0 kB")
     }
 
     @Test
     fun kilobytes_upper_bound() {
-        assertEquals("999.9 kB", sizeFormatter.formatSize(999_949))
+        assertThat(sizeFormatter.formatSize(999_949)).isEqualTo("999.9 kB")
     }
 
     @Test
     fun megabytes_lower_bound() {
-        assertEquals("1.0 MB", sizeFormatter.formatSize(999_950))
+        assertThat(sizeFormatter.formatSize(999_950)).isEqualTo("1.0 MB")
     }
 
     @Test
     fun megabytes_upper_bound() {
-        assertEquals("999.9 MB", sizeFormatter.formatSize(999_949_999))
+        assertThat(sizeFormatter.formatSize(999_949_999)).isEqualTo("999.9 MB")
     }
 
     @Test
     fun gigabytes_lower_bound() {
-        assertEquals("1.0 GB", sizeFormatter.formatSize(999_950_000))
+        assertThat(sizeFormatter.formatSize(999_950_000)).isEqualTo("1.0 GB")
     }
 
     @Test
     fun gigabytes_2() {
-        assertEquals("2.0 GB", sizeFormatter.formatSize(2_000_000_000L))
+        assertThat(sizeFormatter.formatSize(2_000_000_000L)).isEqualTo("2.0 GB")
     }
 
     @Test
     fun gigabytes_2000() {
-        assertEquals("2000.0 GB", sizeFormatter.formatSize(2_000_000_000_000L))
+        assertThat(sizeFormatter.formatSize(2_000_000_000_000L)).isEqualTo("2000.0 GB")
     }
 }
diff --git a/app/ui/legacy/src/test/java/com/fsck/k9/ui/messagedetails/MessageDetailsParticipantFormatterTest.kt b/app/ui/legacy/src/test/java/com/fsck/k9/ui/messagedetails/MessageDetailsParticipantFormatterTest.kt
index 6bba916c647bc92829ec3630e04a658fec76fedc..c7dc7e05d7ed56d2daa2c29e431baf26395d8818 100644
--- a/app/ui/legacy/src/test/java/com/fsck/k9/ui/messagedetails/MessageDetailsParticipantFormatterTest.kt
+++ b/app/ui/legacy/src/test/java/com/fsck/k9/ui/messagedetails/MessageDetailsParticipantFormatterTest.kt
@@ -4,6 +4,7 @@ import android.graphics.Color
 import android.text.Spannable
 import android.text.style.ForegroundColorSpan
 import androidx.core.text.getSpans
+import app.k9mail.core.android.testing.RobolectricTest
 import assertk.assertThat
 import assertk.assertions.containsExactly
 import assertk.assertions.isEqualTo
@@ -12,7 +13,6 @@ import assertk.assertions.isNotNull
 import assertk.assertions.isNull
 import com.fsck.k9.Account
 import com.fsck.k9.Identity
-import com.fsck.k9.RobolectricTest
 import com.fsck.k9.helper.ContactNameProvider
 import com.fsck.k9.mail.Address
 import org.junit.Test
@@ -124,7 +124,7 @@ class MessageDetailsParticipantFormatterTest : RobolectricTest() {
         val displayName = participantFormatter.getDisplayName(Address("user1@domain.example"), account)
 
         assertThat(displayName.toString()).isEqualTo("Contact One")
-        assertThat(displayName).isNotNull().isInstanceOf(Spannable::class.java)
+        assertThat(displayName).isNotNull().isInstanceOf<Spannable>()
         val spans = (displayName as Spannable).getSpans<ForegroundColorSpan>(0, displayName.length)
         assertThat(spans.map { it.foregroundColor }).containsExactly(Color.RED)
     }
diff --git a/app/ui/legacy/src/test/java/com/fsck/k9/ui/messagelist/MessageListAdapterTest.kt b/app/ui/legacy/src/test/java/com/fsck/k9/ui/messagelist/MessageListAdapterTest.kt
index b4da61c8c2373ea0236311ce3f1772618a2026b9..7ea061c924ad65bbd32ddaa66959f424ceb47030 100644
--- a/app/ui/legacy/src/test/java/com/fsck/k9/ui/messagelist/MessageListAdapterTest.kt
+++ b/app/ui/legacy/src/test/java/com/fsck/k9/ui/messagelist/MessageListAdapterTest.kt
@@ -11,22 +11,23 @@ import android.widget.TextView
 import androidx.appcompat.app.AppCompatActivity
 import androidx.core.view.isGone
 import androidx.core.view.isVisible
+import app.k9mail.core.android.testing.RobolectricTest
 import app.k9mail.core.testing.TestClock
+import assertk.Assert
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.isNull
+import assertk.assertions.support.expected
 import com.fsck.k9.Account
 import com.fsck.k9.FontSizes
 import com.fsck.k9.FontSizes.FONT_DEFAULT
 import com.fsck.k9.FontSizes.LARGE
-import com.fsck.k9.RobolectricTest
 import com.fsck.k9.UiDensity
 import com.fsck.k9.contacts.ContactPictureLoader
 import com.fsck.k9.mail.Address
 import com.fsck.k9.textString
 import com.fsck.k9.ui.R
 import com.fsck.k9.ui.helper.RelativeDateTimeFormatter
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertFalse
-import org.junit.Assert.assertNull
-import org.junit.Assert.assertTrue
 import org.junit.Test
 import org.mockito.kotlin.mock
 import org.robolectric.Robolectric
@@ -49,7 +50,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView()
 
-        assertTrue(view.accountChipView.isVisible)
+        assertThat(view.accountChipView).isVisible()
     }
 
     @Test
@@ -58,7 +59,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView()
 
-        assertTrue(view.accountChipView.isGone)
+        assertThat(view.accountChipView).isGone()
     }
 
     @Test
@@ -67,7 +68,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView()
 
-        assertTrue(view.starView.isGone)
+        assertThat(view.starView).isGone()
     }
 
     @Test
@@ -77,7 +78,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView(messageListItem)
 
-        assertTrue(view.starView.isVisible)
+        assertThat(view.starView).isVisible()
     }
 
     @Test
@@ -87,7 +88,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView(messageListItem)
 
-        assertFalse(view.starView.isSelected)
+        assertThat(view.starView).isNotSelected()
     }
 
     @Test
@@ -97,7 +98,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView(messageListItem)
 
-        assertTrue(view.threadCountView.isGone)
+        assertThat(view.threadCountView).isGone()
     }
 
     @Test
@@ -107,8 +108,8 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView(messageListItem)
 
-        assertTrue(view.threadCountView.isVisible)
-        assertEquals("13", view.threadCountView.textString)
+        assertThat(view.threadCountView).isVisible()
+        assertThat(view.threadCountView.textString).isEqualTo("13")
     }
 
     @Test
@@ -118,7 +119,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView(messageListItem)
 
-        assertEquals("Subject", view.firstLineView.textString)
+        assertThat(view.firstLineView.textString).isEqualTo("Subject")
     }
 
     @Test
@@ -128,7 +129,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView(messageListItem)
 
-        assertEquals("Display Name", view.firstLineView.textString)
+        assertThat(view.firstLineView.textString).isEqualTo("Display Name")
     }
 
     @Test
@@ -138,7 +139,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView(messageListItem)
 
-        assertTrue(view.firstLineView.containsNoSubjectIndicator())
+        assertThat(view.firstLineView.textString).isMissingSubjectText()
     }
 
     @Test
@@ -148,7 +149,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView(messageListItem)
 
-        assertTrue(view.firstLineView.containsNoSubjectIndicator())
+        assertThat(view.firstLineView.textString).isMissingSubjectText()
     }
 
     @Test
@@ -158,7 +159,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView(messageListItem)
 
-        assertTrue(view.attachmentCountView.isGone)
+        assertThat(view.attachmentCountView).isGone()
     }
 
     @Test
@@ -168,7 +169,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView(messageListItem)
 
-        assertTrue(view.attachmentCountView.isVisible)
+        assertThat(view.attachmentCountView).isVisible()
     }
 
     @Test
@@ -180,7 +181,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView()
 
-        assertEquals(FIRST_LINE_DEFAULT_FONT_SIZE, view.firstLineView.textSize)
+        assertThat(view.firstLineView.textSize).isEqualTo(FIRST_LINE_DEFAULT_FONT_SIZE)
     }
 
     @Test
@@ -192,7 +193,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView()
 
-        assertEquals(22f, view.firstLineView.textSize)
+        assertThat(view.firstLineView.textSize).isEqualTo(22f)
     }
 
     @Test
@@ -204,7 +205,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView()
 
-        assertEquals(FIRST_LINE_DEFAULT_FONT_SIZE, view.firstLineView.textSize)
+        assertThat(view.firstLineView.textSize).isEqualTo(FIRST_LINE_DEFAULT_FONT_SIZE)
     }
 
     @Test
@@ -216,7 +217,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView()
 
-        assertEquals(22f, view.firstLineView.textSize)
+        assertThat(view.firstLineView.textSize).isEqualTo(22f)
     }
 
     @Test
@@ -228,7 +229,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView()
 
-        assertNull(view.secondLineView.getFirstAbsoluteSizeSpanValueOrNull())
+        assertThat(view.secondLineView.text).firstAbsoluteSizeSpanValue().isNull()
     }
 
     @Test
@@ -240,7 +241,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView()
 
-        assertNull(view.secondLineView.getFirstAbsoluteSizeSpanValueOrNull())
+        assertThat(view.secondLineView.text).firstAbsoluteSizeSpanValue().isNull()
     }
 
     @Test
@@ -249,7 +250,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView()
 
-        assertEquals(22f, view.dateView.textSize)
+        assertThat(view.dateView.textSize).isEqualTo(22f)
     }
 
     @Test
@@ -261,7 +262,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView()
 
-        assertEquals(SECOND_LINE_DEFAULT_FONT_SIZE, view.secondLineView.textSize)
+        assertThat(view.secondLineView.textSize).isEqualTo(SECOND_LINE_DEFAULT_FONT_SIZE)
     }
 
     @Test
@@ -273,7 +274,7 @@ class MessageListAdapterTest : RobolectricTest() {
 
         val view = adapter.createAndBindView()
 
-        assertEquals(22f, view.secondLineView.textSize)
+        assertThat(view.secondLineView.textSize).isEqualTo(22f)
     }
 
     fun createFontSizes(
@@ -385,10 +386,36 @@ class MessageListAdapterTest : RobolectricTest() {
     val View.attachmentCountView: View get() = findViewById(R.id.attachment)
     val View.dateView: TextView get() = findViewById(R.id.date)
 
-    fun TextView.containsNoSubjectIndicator() = textString.contains(context.getString(R.string.general_no_subject))
+    private fun Assert<View>.isVisible() = given { actual ->
+        if (!actual.isVisible) {
+            expected("View to be visible ($actual)")
+        }
+    }
+
+    private fun Assert<View>.isGone() = given { actual ->
+        if (!actual.isGone) {
+            expected("View to be gone ($actual)")
+        }
+    }
+
+    private fun Assert<View>.isSelected() = given { actual ->
+        if (!actual.isSelected) {
+            expected("View to be selected ($actual)")
+        }
+    }
+
+    private fun Assert<View>.isNotSelected() = given { actual ->
+        if (actual.isSelected) {
+            expected("View to not be selected ($actual)")
+        }
+    }
+
+    private fun Assert<CharSequence>.isMissingSubjectText() {
+        isEqualTo(context.getString(R.string.general_no_subject))
+    }
 
-    fun TextView.getFirstAbsoluteSizeSpanValueOrNull(): Int? {
+    private fun Assert<CharSequence>.firstAbsoluteSizeSpanValue() = transform { text ->
         val spans = (text as Spannable).getSpans(0, text.length, AbsoluteSizeSpan::class.java)
-        return spans.firstOrNull()?.size
+        spans.firstOrNull()?.size
     }
 }
diff --git a/app/ui/legacy/src/test/java/com/fsck/k9/ui/messageview/DisplayRecipientsExtractorTest.kt b/app/ui/legacy/src/test/java/com/fsck/k9/ui/messageview/DisplayRecipientsExtractorTest.kt
index 1ed5ec706585c1389cb286bea0e52665f2cdd0e7..3ede76992d2d73be9cb5f2980fd83fdaba3996dd 100644
--- a/app/ui/legacy/src/test/java/com/fsck/k9/ui/messageview/DisplayRecipientsExtractorTest.kt
+++ b/app/ui/legacy/src/test/java/com/fsck/k9/ui/messageview/DisplayRecipientsExtractorTest.kt
@@ -19,13 +19,16 @@ class DisplayRecipientsExtractorTest {
 
     private val recipientFormatter = object : MessageViewRecipientFormatter {
         override fun getDisplayName(address: Address, account: Account): CharSequence {
-            return when (address.address) {
-                IDENTITY_ADDRESS -> "me"
-                "user1@domain.example" -> "Contact One"
-                "user2@domain.example" -> "Contact Two"
-                "user3@domain.example" -> "Contact Three"
-                "user4@domain.example" -> "Contact Four"
-                else -> address.personal ?: address.address
+            return if (account.isAnIdentity(address)) {
+                "me"
+            } else {
+                when (address.address) {
+                    "user1@domain.example" -> "Contact One"
+                    "user2@domain.example" -> "Contact Two"
+                    "user3@domain.example" -> "Contact Three"
+                    "user4@domain.example" -> "Contact Four"
+                    else -> address.personal ?: address.address
+                }
             }
         }
     }
@@ -48,6 +51,45 @@ class DisplayRecipientsExtractorTest {
         )
     }
 
+    @Test
+    fun `single recipient is identity address with different local part case`() {
+        val message = buildMessage {
+            header("To", "Test User <ME@domain.example>")
+        }
+
+        val displayRecipients = displayRecipientsExtractor.extractDisplayRecipients(message, account)
+
+        assertThat(displayRecipients).isEqualTo(
+            DisplayRecipients(recipientNames = listOf("me"), numberOfRecipients = 1),
+        )
+    }
+
+    @Test
+    fun `single recipient is identity address with different domain case`() {
+        val message = buildMessage {
+            header("To", "Test User <me@DOMAIN.EXAMPLE>")
+        }
+
+        val displayRecipients = displayRecipientsExtractor.extractDisplayRecipients(message, account)
+
+        assertThat(displayRecipients).isEqualTo(
+            DisplayRecipients(recipientNames = listOf("me"), numberOfRecipients = 1),
+        )
+    }
+
+    @Test
+    fun `single recipient is identity address with different local part and domain case`() {
+        val message = buildMessage {
+            header("To", "Test User <ME@DOMAIN.EXAMPLE>")
+        }
+
+        val displayRecipients = displayRecipientsExtractor.extractDisplayRecipients(message, account)
+
+        assertThat(displayRecipients).isEqualTo(
+            DisplayRecipients(recipientNames = listOf("me"), numberOfRecipients = 1),
+        )
+    }
+
     @Test
     fun `single recipient is a contact`() {
         val message = buildMessage {
diff --git a/app/ui/legacy/src/test/java/com/fsck/k9/ui/messageview/MessageViewRecipientFormatterTest.kt b/app/ui/legacy/src/test/java/com/fsck/k9/ui/messageview/MessageViewRecipientFormatterTest.kt
index c75099ded658f840182a67b5b7003c20d8be5ec7..7693d8e8c36e4618c8edf0a70893e4b518ffb3f8 100644
--- a/app/ui/legacy/src/test/java/com/fsck/k9/ui/messageview/MessageViewRecipientFormatterTest.kt
+++ b/app/ui/legacy/src/test/java/com/fsck/k9/ui/messageview/MessageViewRecipientFormatterTest.kt
@@ -4,13 +4,13 @@ import android.graphics.Color
 import android.text.Spannable
 import android.text.style.ForegroundColorSpan
 import androidx.core.text.getSpans
+import app.k9mail.core.android.testing.RobolectricTest
 import assertk.assertThat
 import assertk.assertions.containsExactly
 import assertk.assertions.isEqualTo
 import assertk.assertions.isInstanceOf
 import com.fsck.k9.Account
 import com.fsck.k9.Identity
-import com.fsck.k9.RobolectricTest
 import com.fsck.k9.helper.ContactNameProvider
 import com.fsck.k9.mail.Address
 import org.junit.Test
@@ -133,7 +133,7 @@ class MessageViewRecipientFormatterTest : RobolectricTest() {
         val displayName = recipientFormatter.getDisplayName(Address("user1@domain.example"), account)
 
         assertThat(displayName.toString()).isEqualTo("Contact One")
-        assertThat(displayName).isInstanceOf(Spannable::class.java)
+        assertThat(displayName).isInstanceOf<Spannable>()
         val spans = (displayName as Spannable).getSpans<ForegroundColorSpan>(0, displayName.length)
         assertThat(spans.map { it.foregroundColor }).containsExactly(Color.RED)
     }
diff --git a/app/ui/legacy/src/test/java/com/fsck/k9/ui/messageview/RecipientLayoutCreatorTest.kt b/app/ui/legacy/src/test/java/com/fsck/k9/ui/messageview/RecipientLayoutCreatorTest.kt
index d277050eab4c41f707b7a2ad7c942fd53188bf53..b9d1a3c31e236bafa563ab2b7d72a0c67b33681b 100644
--- a/app/ui/legacy/src/test/java/com/fsck/k9/ui/messageview/RecipientLayoutCreatorTest.kt
+++ b/app/ui/legacy/src/test/java/com/fsck/k9/ui/messageview/RecipientLayoutCreatorTest.kt
@@ -1,9 +1,9 @@
 package com.fsck.k9.ui.messageview
 
+import app.k9mail.core.android.testing.RobolectricTest
 import assertk.assertThat
 import assertk.assertions.isEqualTo
 import assertk.assertions.isNull
-import com.fsck.k9.RobolectricTest
 import org.junit.Test
 
 class RecipientLayoutCreatorTest : RobolectricTest() {
diff --git a/app/ui/legacy/src/test/java/com/fsck/k9/view/UserInputEmailAddressParserTest.kt b/app/ui/legacy/src/test/java/com/fsck/k9/view/UserInputEmailAddressParserTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..f1ecb2d60530d77d91323eb8f795dc6a36c867dd
--- /dev/null
+++ b/app/ui/legacy/src/test/java/com/fsck/k9/view/UserInputEmailAddressParserTest.kt
@@ -0,0 +1,153 @@
+package com.fsck.k9.view
+
+import assertk.assertFailure
+import assertk.assertThat
+import assertk.assertions.containsExactly
+import assertk.assertions.isEmpty
+import assertk.assertions.isInstanceOf
+import com.fsck.k9.mail.Address
+import kotlin.test.Ignore
+import kotlin.test.Test
+
+class UserInputEmailAddressParserTest {
+    private val parser = UserInputEmailAddressParser()
+
+    @Test
+    fun `plain email address`() {
+        val addresses = parser.parse("user@domain.example")
+
+        assertThat(addresses).containsExactly(Address("user@domain.example"))
+    }
+
+    @Test
+    fun `email address followed by space`() {
+        val addresses = parser.parse("user@domain.example ")
+
+        assertThat(addresses).containsExactly(Address("user@domain.example"))
+    }
+
+    @Test
+    fun `email address in angle brackets`() {
+        val addresses = parser.parse("<user@domain.example>")
+
+        assertThat(addresses).containsExactly(Address("user@domain.example"))
+    }
+
+    @Test
+    fun `simple name and address`() {
+        val addresses = parser.parse("Name <user@domain.example>")
+
+        assertThat(addresses).containsExactly(Address("user@domain.example", "Name"))
+    }
+
+    @Test
+    fun `name with quoted string and address`() {
+        val addresses = parser.parse("\"Name\" <user@domain.example>")
+
+        assertThat(addresses).containsExactly(Address("user@domain.example", "Name"))
+    }
+
+    @Test
+    fun `name with multiple words and address`() {
+        val addresses = parser.parse("Firstname Lastname <user@domain.example>")
+
+        assertThat(addresses).containsExactly(Address("user@domain.example", "Firstname Lastname"))
+    }
+
+    @Test
+    fun `name with non-ASCII characters and address`() {
+        val addresses = parser.parse("Käthe Gehäusegröße <user@domain.example>")
+
+        assertThat(addresses).containsExactly(Address("user@domain.example", "Käthe Gehäusegröße"))
+    }
+
+    @Test
+    fun `address with non-ASCII character in local part`() {
+        assertFailure {
+            parser.parse("müller@domain.example")
+        }.isInstanceOf<NonAsciiEmailAddressException>()
+    }
+
+    @Test
+    fun `address with non-ASCII character in domain part`() {
+        assertFailure {
+            parser.parse("user@dömain.example")
+        }.isInstanceOf<NonAsciiEmailAddressException>()
+    }
+
+    @Test
+    fun `multiple addresses separated by comma`() {
+        val addresses = parser.parse("one@domain.example,<two@domain.example>")
+
+        assertThat(addresses).containsExactly(
+            Address("one@domain.example"),
+            Address("two@domain.example"),
+        )
+    }
+
+    @Test
+    @Ignore("Currently not supported")
+    fun `multiple addresses separated by space`() {
+        val addresses = parser.parse("one@domain.example two@domain.example")
+
+        assertThat(addresses).containsExactly(
+            Address("one@domain.example"),
+            Address("two@domain.example"),
+        )
+    }
+
+    @Test
+    fun `multiple addresses in angle brackets separated by space`() {
+        val addresses = parser.parse("<one@domain.example>, <two@domain.example>")
+
+        assertThat(addresses).containsExactly(
+            Address("one@domain.example"),
+            Address("two@domain.example"),
+        )
+    }
+
+    @Test
+    fun `incomplete address should not return a result`() {
+        val addresses = parser.parse("user")
+
+        assertThat(addresses).isEmpty()
+    }
+
+    @Test
+    fun `incomplete address ending in @ should not return a result`() {
+        val addresses = parser.parse("user@")
+
+        assertThat(addresses).isEmpty()
+    }
+
+    @Test
+    fun `name and incomplete address should not return a result`() {
+        val addresses = parser.parse("Name <user")
+
+        assertThat(addresses).isEmpty()
+    }
+
+    @Test
+    @Ignore("Currently not supported")
+    fun `name followed by address not in angle brackets`() {
+        val addresses = parser.parse("Firstname Lastname user@domain.example")
+
+        assertThat(addresses).containsExactly(Address("user@domain.example", "Firstname LastName"))
+    }
+
+    @Test
+    @Ignore("Currently not supported")
+    fun `name containing parenthesis`() {
+        val addresses = parser.parse("Firstname (Nickname) Lastname <user@domain.example>")
+
+        assertThat(addresses).containsExactly(Address("user@domain.example", "Firstname (Nickname) LastName"))
+    }
+
+    @Test
+    @Ignore("Currently not supported")
+    fun `name containing double quotes in the middle`() {
+        val addresses = parser.parse("Firstname \"Nickname\" Lastname <user@domain.example>")
+
+        assertThat(addresses).containsExactly(Address("user@domain.example", "Firstname \"Nickname\" LastName"))
+    }
+}
diff --git a/app/ui/message-list-widget/src/main/java/app/k9mail/ui/widget/list/MessageListWidgetManager.kt b/app/ui/message-list-widget/src/main/java/app/k9mail/ui/widget/list/MessageListWidgetManager.kt
index 6eab9f1d38ba46dd28c96cf5ed02cbcc89faa7be..3335c482cdc2de48b675d513b3509eeca6be07b3 100644
--- a/app/ui/message-list-widget/src/main/java/app/k9mail/ui/widget/list/MessageListWidgetManager.kt
+++ b/app/ui/message-list-widget/src/main/java/app/k9mail/ui/widget/list/MessageListWidgetManager.kt
@@ -14,7 +14,7 @@ class MessageListWidgetManager(
     private val messageListRepository: MessageListRepository,
     private val config: MessageListWidgetConfig,
 ) {
-    private lateinit var appWidgetManager: AppWidgetManager
+    private var appWidgetManager: AppWidgetManager? = null
 
     private var listenerAdded = false
     private val listener = MessageListChangedListener {
@@ -23,6 +23,9 @@ class MessageListWidgetManager(
 
     fun init() {
         appWidgetManager = AppWidgetManager.getInstance(context)
+        if (appWidgetManager == null) {
+            Timber.v("Message list widget is not supported on this device.")
+        }
 
         if (isAtLeastOneMessageListWidgetAdded()) {
             resetMessageListWidget()
@@ -83,7 +86,7 @@ class MessageListWidgetManager(
     private fun triggerMessageListWidgetUpdate() {
         val appWidgetIds = getAppWidgetIds()
         if (appWidgetIds.isNotEmpty()) {
-            appWidgetManager.notifyAppWidgetViewDataChanged(appWidgetIds, R.id.listView)
+            appWidgetManager?.notifyAppWidgetViewDataChanged(appWidgetIds, R.id.listView)
         }
     }
 
@@ -101,6 +104,6 @@ class MessageListWidgetManager(
 
     private fun getAppWidgetIds(): IntArray {
         val componentName = ComponentName(context, config.providerClass)
-        return appWidgetManager.getAppWidgetIds(componentName)
+        return appWidgetManager?.getAppWidgetIds(componentName) ?: intArrayOf()
     }
 }
diff --git a/app/ui/message-list-widget/src/main/res/drawable-xxhdpi/message_list_widget_preview.png b/app/ui/message-list-widget/src/main/res/drawable-xxhdpi/message_list_widget_preview.png
index 3c88d00223a08f5341df33ecf3199cf33072fe4f..32c20f9b022a2b147ca0b039badf8d9419793a3b 100644
Binary files a/app/ui/message-list-widget/src/main/res/drawable-xxhdpi/message_list_widget_preview.png and b/app/ui/message-list-widget/src/main/res/drawable-xxhdpi/message_list_widget_preview.png differ
diff --git a/app/ui/message-list-widget/src/main/res/layout/message_list_widget_layout.xml b/app/ui/message-list-widget/src/main/res/layout/message_list_widget_layout.xml
index f7e889e0ccecc576f95da2cfcb44353c4bf8fa18..fc2ba4b018c346a4ad907b9585a717a6c138faa8 100644
--- a/app/ui/message-list-widget/src/main/res/layout/message_list_widget_layout.xml
+++ b/app/ui/message-list-widget/src/main/res/layout/message_list_widget_layout.xml
@@ -32,7 +32,7 @@
             android:background="?android:attr/selectableItemBackground"
             android:contentDescription="@string/compose_action"
             android:scaleType="center"
-            android:src="@drawable/ic_envelope" />
+            android:src="@drawable/ic_pencil" />
 
     </LinearLayout>
 
diff --git a/autodiscovery b/autodiscovery
new file mode 100755
index 0000000000000000000000000000000000000000..b64e697bbd5636ff5ebc341edc8e16ecacba9f8d
--- /dev/null
+++ b/autodiscovery
@@ -0,0 +1,3 @@
+#!/bin/sh
+
+./gradlew --quiet ":cli:autodiscovery-cli:installDist" < /dev/null && ./cli/autodiscovery-cli/build/install/autodiscovery-cli/bin/autodiscovery-cli "$@"
diff --git a/backend/api/src/main/java/com/fsck/k9/backend/api/Backend.kt b/backend/api/src/main/java/com/fsck/k9/backend/api/Backend.kt
index 4b2073cebe95e86daf57c368cbfc64bd56e829d1..80299d8d7cda5d17b055932afe19b495a1809ba6 100644
--- a/backend/api/src/main/java/com/fsck/k9/backend/api/Backend.kt
+++ b/backend/api/src/main/java/com/fsck/k9/backend/api/Backend.kt
@@ -14,6 +14,7 @@ interface Backend {
     val supportsUpload: Boolean
     val supportsTrashFolder: Boolean
     val supportsSearchByDate: Boolean
+    val supportsFolderSubscriptions: Boolean
     val isPushCapable: Boolean
 
     @Throws(MessagingException::class)
diff --git a/backend/demo/src/main/java/app/k9mail/backend/demo/DemoBackend.kt b/backend/demo/src/main/java/app/k9mail/backend/demo/DemoBackend.kt
index 179b7b6af4d87b49b04c5fd54d620a5cc0a4faef..c207a70cc4c636111bfc986f3cf5083d1311ec70 100644
--- a/backend/demo/src/main/java/app/k9mail/backend/demo/DemoBackend.kt
+++ b/backend/demo/src/main/java/app/k9mail/backend/demo/DemoBackend.kt
@@ -35,6 +35,7 @@ class DemoBackend(private val backendStorage: BackendStorage) : Backend {
     override val supportsUpload: Boolean = true
     override val supportsTrashFolder: Boolean = true
     override val supportsSearchByDate: Boolean = false
+    override val supportsFolderSubscriptions: Boolean = false
     override val isPushCapable: Boolean = false
 
     override fun refreshFolderList() {
diff --git a/backend/demo/src/main/resources/contents.json b/backend/demo/src/main/resources/contents.json
index f0f75a8e00e43776166ea38a221cf327fe1f3f1e..137551a3b909c74b6b1fe9e11ca7571a3534bf3f 100644
--- a/backend/demo/src/main/resources/contents.json
+++ b/backend/demo/src/main/resources/contents.json
@@ -8,7 +8,8 @@
       "thread_1",
       "thread_2",
       "inline_image_data_uri",
-      "inline_image_attachment"
+      "inline_image_attachment",
+      "localpart_exceeds_length_limit"
     ]
   },
   "trash": {
diff --git a/backend/demo/src/main/resources/inbox/localpart_exceeds_length_limit.eml b/backend/demo/src/main/resources/inbox/localpart_exceeds_length_limit.eml
new file mode 100644
index 0000000000000000000000000000000000000000..2aa0ecb1f06925c3d5354c45790e8e1256c53ae6
--- /dev/null
+++ b/backend/demo/src/main/resources/inbox/localpart_exceeds_length_limit.eml
@@ -0,0 +1,9 @@
+MIME-Version: 1.0
+From: Sender <aaaaaaaaaabbbbbbbbbbccccccccccddddddddddeeeeeeeeeeffffffffffggggg@k9mail.example> (local part exceeds maximum length)
+Date: Thu, 15 Jun 2023 18:00:00 +0200
+Message-ID: <localpart@k9mail.example>
+Subject: Localpart of email address exceeds 64 characters
+To: User <user@k9mail.example>
+Content-Type: text/plain; charset=UTF-8
+
+You should still be able to read this message.
diff --git a/backend/imap/src/main/java/com/fsck/k9/backend/imap/ImapBackend.kt b/backend/imap/src/main/java/com/fsck/k9/backend/imap/ImapBackend.kt
index 9d342b76cf73b2da11c4a524b33c860aee576a59..6dfca40e3a4a5a53af433a9cdfb36e6338f675ec 100644
--- a/backend/imap/src/main/java/com/fsck/k9/backend/imap/ImapBackend.kt
+++ b/backend/imap/src/main/java/com/fsck/k9/backend/imap/ImapBackend.kt
@@ -44,6 +44,7 @@ class ImapBackend(
     override val supportsUpload = true
     override val supportsTrashFolder = true
     override val supportsSearchByDate = true
+    override val supportsFolderSubscriptions = true
     override val isPushCapable = true
 
     override fun refreshFolderList() {
diff --git a/backend/jmap/src/main/java/com/fsck/k9/backend/jmap/JmapBackend.kt b/backend/jmap/src/main/java/com/fsck/k9/backend/jmap/JmapBackend.kt
index 14009b21c29cd9621635d83747dc4907b676bf22..8a18c3dce818fefd48dcaa08c053e34c604e385a 100644
--- a/backend/jmap/src/main/java/com/fsck/k9/backend/jmap/JmapBackend.kt
+++ b/backend/jmap/src/main/java/com/fsck/k9/backend/jmap/JmapBackend.kt
@@ -38,6 +38,7 @@ class JmapBackend(
     override val supportsUpload = true
     override val supportsTrashFolder = true
     override val supportsSearchByDate = true
+    override val supportsFolderSubscriptions = false // TODO: add support
     override val isPushCapable = false // FIXME
 
     override fun refreshFolderList() {
diff --git a/backend/jmap/src/test/java/com/fsck/k9/backend/jmap/CommandRefreshFolderListTest.kt b/backend/jmap/src/test/java/com/fsck/k9/backend/jmap/CommandRefreshFolderListTest.kt
index d2f5db91b64329b4a6e03e13f86b9c2c6a9c4663..018a020e639fba531e9f459876be0677d13da8ec 100644
--- a/backend/jmap/src/test/java/com/fsck/k9/backend/jmap/CommandRefreshFolderListTest.kt
+++ b/backend/jmap/src/test/java/com/fsck/k9/backend/jmap/CommandRefreshFolderListTest.kt
@@ -1,18 +1,21 @@
 package com.fsck.k9.backend.jmap
 
 import app.k9mail.backend.testing.InMemoryBackendStorage
+import assertk.assertFailure
+import assertk.assertThat
+import assertk.assertions.containsExactlyInAnyOrder
+import assertk.assertions.isEqualTo
+import assertk.assertions.isInstanceOf
+import assertk.assertions.isTrue
+import assertk.fail
 import com.fsck.k9.backend.api.BackendFolderUpdater
 import com.fsck.k9.backend.api.FolderInfo
 import com.fsck.k9.backend.api.updateFolders
 import com.fsck.k9.mail.AuthenticationFailedException
 import com.fsck.k9.mail.FolderType
 import com.fsck.k9.mail.MessagingException
-import junit.framework.AssertionFailedError
 import okhttp3.HttpUrl
 import okhttp3.mockwebserver.MockResponse
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertTrue
-import org.junit.Assert.fail
 import org.junit.Test
 import rs.ltt.jmap.client.JmapClient
 
@@ -25,11 +28,9 @@ class CommandRefreshFolderListTest {
             MockResponse().setResponseCode(401),
         )
 
-        try {
+        assertFailure {
             command.refreshFolderList()
-            fail("Expected exception")
-        } catch (e: AuthenticationFailedException) {
-        }
+        }.isInstanceOf<AuthenticationFailedException>()
     }
 
     @Test
@@ -38,12 +39,10 @@ class CommandRefreshFolderListTest {
             MockResponse().setBody("invalid"),
         )
 
-        try {
+        assertFailure {
             command.refreshFolderList()
-            fail("Expected exception")
-        } catch (e: MessagingException) {
-            assertTrue(e.isPermanentFailure)
-        }
+        }.isInstanceOf<MessagingException>()
+            .transform { it.isPermanentFailure }.isTrue()
     }
 
     @Test
@@ -162,18 +161,17 @@ class CommandRefreshFolderListTest {
     }
 
     private fun assertFolderList(vararg folderServerIds: String) {
-        assertEquals(folderServerIds.toSet(), backendStorage.getFolderServerIds().toSet())
+        assertThat(backendStorage.getFolderServerIds()).containsExactlyInAnyOrder(*folderServerIds)
     }
 
     private fun assertFolderPresent(serverId: String, name: String, type: FolderType) {
-        val folder = backendStorage.folders[serverId]
-            ?: throw AssertionFailedError("Expected folder '$serverId' in BackendStorage")
+        val folder = backendStorage.folders[serverId] ?: fail("Expected folder '$serverId' in BackendStorage")
 
-        assertEquals(name, folder.name)
-        assertEquals(type, folder.type)
+        assertThat(folder.name).isEqualTo(name)
+        assertThat(folder.type).isEqualTo(type)
     }
 
     private fun assertMailboxState(expected: String) {
-        assertEquals(expected, backendStorage.getExtraString("jmapState"))
+        assertThat(backendStorage.getExtraString("jmapState")).isEqualTo(expected)
     }
 }
diff --git a/backend/jmap/src/test/java/com/fsck/k9/backend/jmap/CommandSyncTest.kt b/backend/jmap/src/test/java/com/fsck/k9/backend/jmap/CommandSyncTest.kt
index 94cf2fe148651f55c2d180a607afdaa11b03e323..d2a0d16cc8aaa0e069cbe9c51edc8dfc66dd1407 100644
--- a/backend/jmap/src/test/java/com/fsck/k9/backend/jmap/CommandSyncTest.kt
+++ b/backend/jmap/src/test/java/com/fsck/k9/backend/jmap/CommandSyncTest.kt
@@ -2,6 +2,12 @@ package com.fsck.k9.backend.jmap
 
 import app.k9mail.backend.testing.InMemoryBackendFolder
 import app.k9mail.backend.testing.InMemoryBackendStorage
+import assertk.assertThat
+import assertk.assertions.containsOnly
+import assertk.assertions.isEmpty
+import assertk.assertions.isEqualTo
+import assertk.assertions.isInstanceOf
+import assertk.assertions.isNotNull
 import com.fsck.k9.backend.api.FolderInfo
 import com.fsck.k9.backend.api.SyncConfig
 import com.fsck.k9.backend.api.SyncConfig.ExpungePolicy
@@ -16,7 +22,6 @@ import okhttp3.HttpUrl
 import okhttp3.OkHttpClient
 import okhttp3.mockwebserver.MockResponse
 import okhttp3.mockwebserver.MockWebServer
-import org.junit.Assert.assertEquals
 import org.junit.Before
 import org.junit.Test
 import rs.ltt.jmap.client.JmapClient
@@ -49,9 +54,9 @@ class CommandSyncTest {
 
         command.sync(FOLDER_SERVER_ID, syncConfig, syncListener)
 
-        assertEquals(SyncListenerEvent.SyncStarted(FOLDER_SERVER_ID), syncListener.getNextEvent())
+        assertThat(syncListener.getNextEvent()).isEqualTo(SyncListenerEvent.SyncStarted(FOLDER_SERVER_ID))
         val failedEvent = syncListener.getNextEvent() as SyncListenerEvent.SyncFailed
-        assertEquals(AuthenticationFailedException::class.java, failedEvent.exception!!.javaClass)
+        assertThat(failedEvent.exception).isNotNull().isInstanceOf<AuthenticationFailedException>()
     }
 
     @Test
@@ -103,7 +108,13 @@ class CommandSyncTest {
         command.sync(FOLDER_SERVER_ID, syncConfig, syncListener)
 
         val backendFolder = backendStorage.getFolder(FOLDER_SERVER_ID)
-        assertEquals(setOf("M001", "M002", "M003", "M004", "M005"), backendFolder.getMessageServerIds())
+        assertThat(backendFolder.getMessageServerIds()).containsOnly(
+            "M001",
+            "M002",
+            "M003",
+            "M004",
+            "M005",
+        )
         syncListener.assertSyncSuccess()
     }
 
@@ -145,7 +156,7 @@ class CommandSyncTest {
 
         command.sync(FOLDER_SERVER_ID, syncConfig, syncListener)
 
-        assertEquals(emptySet<String>(), backendFolder.getMessageServerIds())
+        assertThat(backendFolder.getMessageServerIds()).isEmpty()
         syncListener.assertSyncEvents(
             SyncListenerEvent.SyncStarted(FOLDER_SERVER_ID),
             SyncListenerEvent.SyncFinished(FOLDER_SERVER_ID),
@@ -168,9 +179,9 @@ class CommandSyncTest {
 
         command.sync(FOLDER_SERVER_ID, syncConfig, syncListener)
 
-        assertEquals(setOf("M001", "M002"), backendFolder.getMessageServerIds())
-        assertEquals(emptySet<Flag>(), backendFolder.getMessageFlags("M001"))
-        assertEquals(setOf(Flag.SEEN), backendFolder.getMessageFlags("M002"))
+        assertThat(backendFolder.getMessageServerIds()).containsOnly("M001", "M002")
+        assertThat(backendFolder.getMessageFlags("M001")).isEmpty()
+        assertThat(backendFolder.getMessageFlags("M002")).containsOnly(Flag.SEEN)
         backendFolder.assertQueryState("50:0")
         syncListener.assertSyncEvents(
             SyncListenerEvent.SyncStarted(FOLDER_SERVER_ID),
@@ -196,7 +207,7 @@ class CommandSyncTest {
 
         command.sync(FOLDER_SERVER_ID, syncConfig, syncListener)
 
-        assertEquals(setOf("M002", "M003"), backendFolder.getMessageServerIds())
+        assertThat(backendFolder.getMessageServerIds()).containsOnly("M002", "M003")
         backendFolder.assertQueryState("51:0")
         syncListener.assertSyncSuccess()
     }
@@ -220,7 +231,7 @@ class CommandSyncTest {
 
         command.sync(FOLDER_SERVER_ID, syncConfig, syncListener)
 
-        assertEquals(setOf("M002", "M003"), backendFolder.getMessageServerIds())
+        assertThat(backendFolder.getMessageServerIds()).containsOnly("M002", "M003")
         backendFolder.assertQueryState("50:0")
         syncListener.assertSyncSuccess()
     }
@@ -246,11 +257,11 @@ class CommandSyncTest {
         val request = takeRequest()
         val requestUrl = request.requestUrl ?: error("No request URL")
         val requestUrlPath = requestUrl.encodedPath + "?" + requestUrl.encodedQuery
-        assertEquals(expected, requestUrlPath)
+        assertThat(requestUrlPath).isEqualTo(expected)
     }
 
     private fun InMemoryBackendFolder.assertQueryState(expected: String) {
-        assertEquals(expected, getFolderExtraString("jmapQueryState"))
+        assertThat(getFolderExtraString("jmapQueryState")).isEqualTo(expected)
     }
 
     private fun InMemoryBackendFolder.setQueryState(queryState: String) {
diff --git a/backend/jmap/src/test/java/com/fsck/k9/backend/jmap/LoggingSyncListener.kt b/backend/jmap/src/test/java/com/fsck/k9/backend/jmap/LoggingSyncListener.kt
index b1aad2a24d57a91119e46c02e602a3218338831e..8d0f2d84af3c7d215d5606e15d6c34925cdfc26c 100644
--- a/backend/jmap/src/test/java/com/fsck/k9/backend/jmap/LoggingSyncListener.kt
+++ b/backend/jmap/src/test/java/com/fsck/k9/backend/jmap/LoggingSyncListener.kt
@@ -1,9 +1,10 @@
 package com.fsck.k9.backend.jmap
 
+import assertk.assertThat
+import assertk.assertions.isEmpty
+import assertk.assertions.isEqualTo
+import assertk.fail
 import com.fsck.k9.backend.api.SyncListener
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertTrue
-import org.junit.Assert.fail
 
 class LoggingSyncListener : SyncListener {
     private val events = mutableListOf<SyncListenerEvent>()
@@ -20,9 +21,10 @@ class LoggingSyncListener : SyncListener {
 
     fun assertSyncEvents(vararg events: SyncListenerEvent) {
         for (event in events) {
-            assertEquals(event, getNextEvent())
+            assertThat(getNextEvent()).isEqualTo(event)
         }
-        assertNoMoreEventsLeft()
+
+        assertThat(this.events).isEmpty()
     }
 
     fun getNextEvent(): SyncListenerEvent {
@@ -30,10 +32,6 @@ class LoggingSyncListener : SyncListener {
         return events.removeAt(0)
     }
 
-    private fun assertNoMoreEventsLeft() {
-        assertTrue("Expected no more events; but still have: $events", events.isEmpty())
-    }
-
     override fun syncStarted(folderServerId: String) {
         events.add(SyncListenerEvent.SyncStarted(folderServerId))
     }
diff --git a/backend/pop3/src/main/java/com/fsck/k9/backend/pop3/Pop3Backend.kt b/backend/pop3/src/main/java/com/fsck/k9/backend/pop3/Pop3Backend.kt
index 90193fc961af1dc77a94f594ed0826906eba250b..befbd0e81784bb5e90810f13dec3be76978d69ea 100644
--- a/backend/pop3/src/main/java/com/fsck/k9/backend/pop3/Pop3Backend.kt
+++ b/backend/pop3/src/main/java/com/fsck/k9/backend/pop3/Pop3Backend.kt
@@ -31,6 +31,7 @@ class Pop3Backend(
     override val supportsUpload = false
     override val supportsTrashFolder = false
     override val supportsSearchByDate = false
+    override val supportsFolderSubscriptions = false
     override val isPushCapable = false
 
     override fun refreshFolderList() {
diff --git a/backend/testing/build.gradle.kts b/backend/testing/build.gradle.kts
index d3bc66988b8e7d93bfd134d7d011432ebfda99cf..eb2e245f6752de9be363600a8f1602d30e607fa7 100644
--- a/backend/testing/build.gradle.kts
+++ b/backend/testing/build.gradle.kts
@@ -8,4 +8,5 @@ dependencies {
 
     implementation(libs.okio)
     implementation(libs.junit)
+    implementation(libs.assertk)
 }
diff --git a/backend/testing/src/main/java/app/k9mail/backend/testing/InMemoryBackendFolder.kt b/backend/testing/src/main/java/app/k9mail/backend/testing/InMemoryBackendFolder.kt
index d1368d9f33bf93be0eae391593eca580afe9347f..6446784f3b70ebb5ba8ab02c00a6ade058e7f866 100644
--- a/backend/testing/src/main/java/app/k9mail/backend/testing/InMemoryBackendFolder.kt
+++ b/backend/testing/src/main/java/app/k9mail/backend/testing/InMemoryBackendFolder.kt
@@ -1,5 +1,7 @@
 package app.k9mail.backend.testing
 
+import assertk.assertThat
+import assertk.assertions.isEqualTo
 import com.fsck.k9.backend.api.BackendFolder
 import com.fsck.k9.backend.api.BackendFolder.MoreMessages
 import com.fsck.k9.mail.Flag
@@ -11,7 +13,6 @@ import java.util.Date
 import okio.Buffer
 import okio.buffer
 import okio.source
-import org.junit.Assert.assertEquals
 
 class InMemoryBackendFolder(override var name: String, var type: FolderType) : BackendFolder {
     val extraStrings: MutableMap<String, String> = mutableMapOf()
@@ -29,12 +30,12 @@ class InMemoryBackendFolder(override var name: String, var type: FolderType) : B
             assertMessageContents(messageServerId, resourceName)
         }
         val messageServerIds = messagePairs.map { it.first }.toSet()
-        assertEquals(messageServerIds, messages.keys)
+        assertThat(messages.keys).isEqualTo(messageServerIds)
     }
 
     private fun assertMessageContents(messageServerId: String, resourceName: String) {
         val message = messages[messageServerId] ?: error("Message $messageServerId not found")
-        assertEquals(loadResource(resourceName), getMessageContents(message))
+        assertThat(getMessageContents(message)).isEqualTo(loadResource(resourceName))
     }
 
     fun createMessages(vararg messagePairs: Pair<String, String>) {
diff --git a/build-plugin/src/main/kotlin/thunderbird.library.jvm.gradle.kts b/build-plugin/src/main/kotlin/thunderbird.library.jvm.gradle.kts
index 82086143ee243ff9ca3285928be0b5471e1417f4..dc849ffea43e2fd49605b2fe91c2cc09569aed13 100644
--- a/build-plugin/src/main/kotlin/thunderbird.library.jvm.gradle.kts
+++ b/build-plugin/src/main/kotlin/thunderbird.library.jvm.gradle.kts
@@ -1,3 +1,5 @@
+import org.gradle.jvm.tasks.Jar
+
 plugins {
     `java-library`
     id("org.jetbrains.kotlin.jvm")
@@ -8,6 +10,13 @@ java {
     targetCompatibility = ThunderbirdProjectConfig.javaCompatibilityVersion
 }
 
+tasks.withType<Jar> {
+    // We want to avoid ending up with multiple JARs having the same name, e.g. "common.jar".
+    // To do this, we use the modified project path as base name, e.g. ":core:common" -> "core.common".
+    val projectDotPath = project.path.split(":").filter { it.isNotEmpty() }.joinToString(separator = ".")
+    archiveBaseName.set(projectDotPath)
+}
+
 configureKotlinJavaCompatibility()
 
 dependencies {
diff --git a/build-plugin/src/main/kotlin/thunderbird.quality.detekt.gradle.kts b/build-plugin/src/main/kotlin/thunderbird.quality.detekt.gradle.kts
index 0d3a06c1526f414a537c93685890d39d3545f479..739d67b308eca626a48af3be6d8306bb44fde282 100644
--- a/build-plugin/src/main/kotlin/thunderbird.quality.detekt.gradle.kts
+++ b/build-plugin/src/main/kotlin/thunderbird.quality.detekt.gradle.kts
@@ -7,11 +7,8 @@ plugins {
 }
 
 configure<DetektExtension> {
-    source = project.files(
-        project.file(project.rootDir),
-    )
-
-    config = project.rootProject.files("config/detekt/detekt.yml")
+    source.setFrom(project.file(project.rootDir))
+    config.setFrom(project.rootProject.files("config/detekt/detekt.yml"))
     baseline = project.rootProject.file("config/detekt/baseline.xml")
 }
 
diff --git a/cli/autodiscovery-cli/build.gradle.kts b/cli/autodiscovery-cli/build.gradle.kts
new file mode 100644
index 0000000000000000000000000000000000000000..274e96222656420d28b3be98cba9065b03c6b6d0
--- /dev/null
+++ b/cli/autodiscovery-cli/build.gradle.kts
@@ -0,0 +1,18 @@
+plugins {
+    id(ThunderbirdPlugins.App.jvm)
+}
+
+version = "unspecified"
+
+application {
+    mainClass.set("app.k9mail.cli.autodiscovery.MainKt")
+}
+
+dependencies {
+    implementation(projects.feature.autodiscovery.api)
+    implementation(projects.feature.autodiscovery.autoconfig)
+
+    implementation(libs.kotlinx.coroutines.core)
+    implementation(libs.clikt)
+    implementation(libs.kxml2)
+}
diff --git a/cli/autodiscovery-cli/src/main/kotlin/app/k9mail/cli/autodiscovery/AutoDiscoveryCli.kt b/cli/autodiscovery-cli/src/main/kotlin/app/k9mail/cli/autodiscovery/AutoDiscoveryCli.kt
new file mode 100644
index 0000000000000000000000000000000000000000..1cdf47d950d6c97a0641ed3b601f2ff85fe0e2f0
--- /dev/null
+++ b/cli/autodiscovery-cli/src/main/kotlin/app/k9mail/cli/autodiscovery/AutoDiscoveryCli.kt
@@ -0,0 +1,70 @@
+package app.k9mail.cli.autodiscovery
+
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult.Settings
+import app.k9mail.autodiscovery.autoconfig.AutoconfigUrlConfig
+import app.k9mail.autodiscovery.autoconfig.createIspDbAutoconfigDiscovery
+import app.k9mail.autodiscovery.autoconfig.createMxLookupAutoconfigDiscovery
+import app.k9mail.autodiscovery.autoconfig.createProviderAutoconfigDiscovery
+import app.k9mail.core.common.mail.toUserEmailAddress
+import com.github.ajalt.clikt.core.CliktCommand
+import com.github.ajalt.clikt.parameters.arguments.argument
+import com.github.ajalt.clikt.parameters.options.flag
+import com.github.ajalt.clikt.parameters.options.option
+import kotlin.time.DurationUnit.MILLISECONDS
+import kotlin.time.toDuration
+import kotlinx.coroutines.runBlocking
+import okhttp3.OkHttpClient.Builder
+import org.koin.core.time.measureDurationForResult
+
+class AutoDiscoveryCli : CliktCommand(
+    help = "Performs the auto-discovery steps used by Thunderbird for Android to find mail server settings",
+) {
+    private val httpsOnly by option(help = "Only perform Autoconfig lookups using HTTPS").flag()
+    private val includeEmailAddress by option(help = "Include email address in Autoconfig lookups").flag()
+
+    private val emailAddress by argument(name = "email", help = "Email address")
+
+    override fun run() {
+        echo("Attempting to find mail server settings for <$emailAddress>…")
+        echo()
+
+        val config = AutoconfigUrlConfig(
+            httpsOnly = httpsOnly,
+            includeEmailAddress = includeEmailAddress,
+        )
+
+        val (discoveryResult, durationInMillis) = measureDurationForResult {
+            runAutoDiscovery(config)
+        }
+
+        if (discoveryResult is Settings) {
+            echo("Found the following mail server settings:")
+            AutoDiscoveryResultFormatter(::echo).output(discoveryResult)
+        } else {
+            echo("Couldn't find any mail server settings.")
+        }
+
+        echo()
+        echo("Duration: ${durationInMillis.toDuration(MILLISECONDS)}")
+    }
+
+    private fun runAutoDiscovery(config: AutoconfigUrlConfig): AutoDiscoveryResult {
+        val okHttpClient = Builder().build()
+        try {
+            val providerDiscovery = createProviderAutoconfigDiscovery(okHttpClient, config)
+            val ispDbDiscovery = createIspDbAutoconfigDiscovery(okHttpClient)
+            val mxDiscovery = createMxLookupAutoconfigDiscovery(okHttpClient)
+
+            val runnables = listOf(providerDiscovery, ispDbDiscovery, mxDiscovery)
+                .flatMap { it.initDiscovery(emailAddress.toUserEmailAddress()) }
+            val serialRunner = SerialRunner(runnables)
+
+            return runBlocking {
+                serialRunner.run()
+            }
+        } finally {
+            okHttpClient.dispatcher.executorService.shutdown()
+        }
+    }
+}
diff --git a/cli/autodiscovery-cli/src/main/kotlin/app/k9mail/cli/autodiscovery/AutoDiscoveryResultFormatter.kt b/cli/autodiscovery-cli/src/main/kotlin/app/k9mail/cli/autodiscovery/AutoDiscoveryResultFormatter.kt
new file mode 100644
index 0000000000000000000000000000000000000000..abc82a7ae74a06a7aefa512d9b932ac430d92e50
--- /dev/null
+++ b/cli/autodiscovery-cli/src/main/kotlin/app/k9mail/cli/autodiscovery/AutoDiscoveryResultFormatter.kt
@@ -0,0 +1,35 @@
+package app.k9mail.cli.autodiscovery
+
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult.Settings
+import app.k9mail.autodiscovery.api.ImapServerSettings
+import app.k9mail.autodiscovery.api.SmtpServerSettings
+
+internal class AutoDiscoveryResultFormatter(private val echo: (String) -> Unit) {
+    fun output(settings: Settings) {
+        val incomingServer = requireNotNull(settings.incomingServerSettings as? ImapServerSettings)
+        val outgoingServer = requireNotNull(settings.outgoingServerSettings as? SmtpServerSettings)
+
+        echo("------------------------------")
+        echo("Source: ${settings.source}")
+        echo("")
+        echo("Incoming server:")
+        echo("  Hostname:            ${incomingServer.hostname.value}")
+        echo("  Port:                ${incomingServer.port.value}")
+        echo("  Connection security: ${incomingServer.connectionSecurity}")
+        echo("  Authentication:      ${incomingServer.authenticationTypes.joinToString()}")
+        echo("  Username:            ${incomingServer.username}")
+        echo("")
+        echo("Outgoing server:")
+        echo("  Hostname:            ${outgoingServer.hostname.value}")
+        echo("  Port:                ${outgoingServer.port.value}")
+        echo("  Connection security: ${outgoingServer.connectionSecurity}")
+        echo("  Authentication:      ${outgoingServer.authenticationTypes.joinToString()}")
+        echo("  Username:            ${outgoingServer.username}")
+        echo("------------------------------")
+        if (settings.isTrusted) {
+            echo("These settings have been retrieved through trusted channels.")
+        } else {
+            echo("At least one UNTRUSTED channel was involved in retrieving these settings.")
+        }
+    }
+}
diff --git a/cli/autodiscovery-cli/src/main/kotlin/app/k9mail/cli/autodiscovery/Main.kt b/cli/autodiscovery-cli/src/main/kotlin/app/k9mail/cli/autodiscovery/Main.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d0cdcf5f0bfbef0ae7edcd4e345efbd3deda194a
--- /dev/null
+++ b/cli/autodiscovery-cli/src/main/kotlin/app/k9mail/cli/autodiscovery/Main.kt
@@ -0,0 +1,3 @@
+package app.k9mail.cli.autodiscovery
+
+fun main(args: Array<String>) = AutoDiscoveryCli().main(args)
diff --git a/cli/autodiscovery-cli/src/main/kotlin/app/k9mail/cli/autodiscovery/SerialRunner.kt b/cli/autodiscovery-cli/src/main/kotlin/app/k9mail/cli/autodiscovery/SerialRunner.kt
new file mode 100644
index 0000000000000000000000000000000000000000..b0fe4eb22fc8a2ded68791062a3820728d82acbf
--- /dev/null
+++ b/cli/autodiscovery-cli/src/main/kotlin/app/k9mail/cli/autodiscovery/SerialRunner.kt
@@ -0,0 +1,45 @@
+package app.k9mail.cli.autodiscovery
+
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult.NetworkError
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult.NoUsableSettingsFound
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult.Settings
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult.UnexpectedException
+import app.k9mail.autodiscovery.api.AutoDiscoveryRunnable
+import com.fsck.k9.logging.Timber
+
+/**
+ * Run a list of [AutoDiscoveryRunnable] one after the other until one returns a [Settings] result.
+ */
+class SerialRunner(private val runnables: List<AutoDiscoveryRunnable>) {
+    suspend fun run(): AutoDiscoveryResult {
+        var networkErrorCount = 0
+        var networkError: NetworkError? = null
+
+        for (runnable in runnables) {
+            when (val discoveryResult = runnable.run()) {
+                is Settings -> {
+                    return discoveryResult
+                }
+                is NetworkError -> {
+                    networkErrorCount++
+                    if (networkError == null) {
+                        networkError = discoveryResult
+                    }
+                }
+                NoUsableSettingsFound -> {
+                    Unit
+                }
+                is UnexpectedException -> {
+                    Timber.w(discoveryResult.exception, "Unexpected exception")
+                }
+            }
+        }
+
+        return if (networkError != null && networkErrorCount == runnables.size) {
+            networkError
+        } else {
+            NoUsableSettingsFound
+        }
+    }
+}
diff --git a/config/detekt/baseline.xml b/config/detekt/baseline.xml
index 0b6df3faa162b776e7c7b95eaff076b2ac19ec9a..e5dd1c9548a4febc4be15c3fe7b2faa234609a2b 100644
--- a/config/detekt/baseline.xml
+++ b/config/detekt/baseline.xml
@@ -2,6 +2,14 @@
 <SmellBaseline>
   <ManuallySuppressedIssues></ManuallySuppressedIssues>
   <CurrentIssues>
+    <ID>CastToNullableType:AccountSetupCheckSettings.kt$AccountSetupCheckSettings$as</ID>
+    <ID>CastToNullableType:MessageList.kt$MessageList$as</ID>
+    <ID>CastToNullableType:MessageViewContainerFragment.kt$MessageViewContainerFragment$as</ID>
+    <ID>CastToNullableType:MessageViewFragment.kt$MessageViewFragment$as</ID>
+    <ID>CastToNullableType:RealImapFolder.kt$RealImapFolder$as</ID>
+    <ID>CastToNullableType:SettingsExporter.kt$SettingsExporter$as</ID>
+    <ID>CastToNullableType:ToolbarBottomSheetDialogFragment.kt$ToolbarBottomSheetDialogFragment$as</ID>
+    <ID>CastToNullableType:VibrationPreference.kt$VibrationPreference$as</ID>
     <ID>ComplexCondition:HttpUriParser.kt$HttpUriParser$!compressionEnabled &amp;&amp; beginSegmentsCount + endSegmentsCount == 8 || compressionEnabled &amp;&amp; beginSegmentsCount + endSegmentsCount &lt; 8</ID>
     <ID>ComplexCondition:MessageListFragment.kt$MessageListFragment$operation == FolderOperation.MOVE &amp;&amp; !messagingController.isMoveCapable(account) || operation == FolderOperation.COPY &amp;&amp; !messagingController.isCopyCapable(account)</ID>
     <ID>ComplexCondition:MessageListFragment.kt$MessageListFragment$operation == FolderOperation.MOVE &amp;&amp; !messagingController.isMoveCapable(message) || operation == FolderOperation.COPY &amp;&amp; !messagingController.isCopyCapable(message)</ID>
@@ -14,7 +22,6 @@
     <ID>ComplexCondition:TextInputLayoutExtensions.kt$text != null &amp;&amp; before &gt; 0 &amp;&amp; (text.isEmpty() || text.length - count == 0)</ID>
     <ID>ComplexCondition:TouchInterceptView.kt$TouchInterceptView$absoluteDeltaY &gt; touchSlop &amp;&amp; absoluteDeltaY &gt; absoluteDeltaX &amp;&amp; (scrollView.canScrollVertically(deltaY.toInt()) || webView.canScrollVertically(deltaY.toInt()))</ID>
     <ID>ComplexCondition:build.gradle.kts$project.hasProperty("k9mail.keyAlias") &amp;&amp; project.hasProperty("k9mail.keyPassword") &amp;&amp; project.hasProperty("k9mail.storeFile") &amp;&amp; project.hasProperty("k9mail.storePassword")</ID>
-    <ID>ConstructorParameterNaming:MessageTopView.kt$MessageTopView.SavedState$`in`: Parcel</ID>
     <ID>CyclomaticComplexMethod:AccountSettingsDataStore.kt$AccountSettingsDataStore$override fun getBoolean(key: String, defValue: Boolean): Boolean</ID>
     <ID>CyclomaticComplexMethod:AccountSettingsDataStore.kt$AccountSettingsDataStore$override fun getString(key: String, defValue: String?): String?</ID>
     <ID>CyclomaticComplexMethod:AccountSettingsDataStore.kt$AccountSettingsDataStore$override fun putBoolean(key: String, value: Boolean)</ID>
@@ -51,8 +58,6 @@
     <ID>CyclomaticComplexMethod:StorageMigrations.kt$StorageMigrations$@JvmStatic fun upgradeDatabase(db: SQLiteDatabase, migrationsHelper: StorageMigrationsHelper)</ID>
     <ID>CyclomaticComplexMethod:TouchInterceptView.kt$TouchInterceptView$private fun handleOnInterceptTouchEvent(event: MotionEvent)</ID>
     <ID>DestructuringDeclarationWithTooManyEntries:RetrieveFolderOperationsTest.kt$RetrieveFolderOperationsTest$val (folderId1, folderId2, folderId3, folderId4) = listOf( sqliteDatabase.createFolder(name = "Folder 1", displayClass = "FIRST_CLASS"), sqliteDatabase.createFolder(name = "Folder 2", displayClass = "SECOND_CLASS"), sqliteDatabase.createFolder(name = "Folder 3", displayClass = "FIRST_CLASS"), sqliteDatabase.createFolder(name = "Folder 4", displayClass = "NO_CLASS"), )</ID>
-    <ID>EmptyCatchBlock:CommandRefreshFolderListTest.kt$CommandRefreshFolderListTest${ }</ID>
-    <ID>EmptyCatchBlock:K9BackendFolderTest.kt$K9BackendFolderTest${ }</ID>
     <ID>ForbiddenComment:AccountSetupCheckSettings.kt$AccountSetupCheckSettings.CheckAccountTask$* FIXME: Don't use an AsyncTask to perform network operations. * See also discussion in https://github.com/thundernest/k-9/pull/560</ID>
     <ID>ForbiddenComment:BackendFolder.kt$BackendFolder$// FIXME: add documentation</ID>
     <ID>ForbiddenComment:CommandSync.kt$CommandSync$// FIXME: Add sort parameter</ID>
@@ -129,27 +134,19 @@
     <ID>LongMethod:TextBodyBuilderTest.kt$TextBodyBuilderTest.Companion$@JvmStatic @Parameterized.Parameters(name = "{index}: {0}") fun data(): Collection&lt;TestData&gt;</ID>
     <ID>LongMethod:ThreadMessageOperationsTest.kt$ThreadMessageOperationsTest$@Test fun `merge two existing threads`()</ID>
     <ID>LongParameterList:CopyMessageOperations.kt$DatabaseMessagePart$( val id: Long, val type: Int, val root: Long, val parent: Long, val seq: Int, val mimeType: String?, val decodedBodySize: Long?, val displayName: String?, val header: ByteArray?, val encoding: String?, val charset: String?, val dataLocation: Int, val data: ByteArray?, val preamble: ByteArray?, val epilogue: ByteArray?, val boundary: String?, val contentId: String?, val serverExtra: String?, )</ID>
-    <ID>LongParameterList:FolderHelpers.kt$( name: String = "irrelevant", type: String = "regular", serverId: String? = null, isLocalOnly: Boolean = true, integrate: Boolean = false, inTopGroup: Boolean = false, displayClass: String = "NO_CLASS", syncClass: String? = "INHERITED", notifyClass: String? = "INHERITED", pushClass: String? = "SECOND_CLASS", lastUpdated: Long = 0L, unreadCount: Int = 0, visibleLimit: Int = 25, status: String? = null, flaggedCount: Int = 0, moreMessages: String = "unknown", )</ID>
     <ID>LongParameterList:ImapSync.kt$ImapSync$( remoteFolder: ImapFolder, backendFolder: BackendFolder, largeMessages: List&lt;ImapMessage&gt;, progress: AtomicInteger, downloadedMessageCount: AtomicInteger, todo: Int, highestKnownUid: Long?, listener: SyncListener, maxDownloadSize: Int, )</ID>
     <ID>LongParameterList:ImapSync.kt$ImapSync$( remoteFolder: ImapFolder, backendFolder: BackendFolder, smallMessages: List&lt;ImapMessage&gt;, progress: AtomicInteger, downloadedMessageCount: AtomicInteger, todo: Int, highestKnownUid: Long?, listener: SyncListener, )</ID>
     <ID>LongParameterList:ImapSync.kt$ImapSync$( syncConfig: SyncConfig, remoteFolder: ImapFolder, unsyncedMessages: List&lt;ImapMessage&gt;, smallMessages: MutableList&lt;ImapMessage&gt;, largeMessages: MutableList&lt;ImapMessage&gt;, progress: AtomicInteger, todo: Int, listener: SyncListener, )</ID>
-    <ID>LongParameterList:MessageDatabaseHelpers.kt$( folderId: Long, deleted: Boolean = false, uid: String? = null, subject: String = "", date: Long = 0L, flags: String = "", senderList: String = "", toList: String = "", ccList: String = "", bccList: String = "", replyToList: String = "", attachmentCount: Int = 0, internalDate: Long = 0L, messageIdHeader: String? = null, previewType: DatabasePreviewType = DatabasePreviewType.NONE, preview: String = "", mimeType: String = "text/plain", normalizedSubjectHash: Long = 0L, empty: Boolean = false, read: Boolean = false, flagged: Boolean = false, answered: Boolean = false, forwarded: Boolean = false, messagePartId: Long = 0L, encryptionType: String? = null, newMessage: Boolean = false, )</ID>
-    <ID>LongParameterList:MessageDatabaseHelpers.kt$( type: Int = 0, root: Int? = null, parent: Int = -1, seq: Int = 0, mimeType: String = "text/plain", decodedBodySize: Int = 0, displayName: String? = null, header: String? = null, encoding: String = "7bit", charset: String? = null, dataLocation: Int = 0, data: ByteArray? = null, preamble: String? = null, epilogue: String? = null, boundary: String? = null, contentId: String? = null, serverExtra: String? = null, directory: File? = null, )</ID>
     <ID>LongParameterList:MessageDetailsViewModel.kt$MessageDetailsViewModel$( private val resources: Resources, private val messageRepository: MessageRepository, private val folderRepository: FolderRepository, private val contactSettingsProvider: ContactSettingsProvider, private val contactRepository: ContactRepository, private val contactPermissionResolver: ContactPermissionResolver, private val clipboardManager: ClipboardManager, private val accountManager: AccountManager, private val participantFormatter: MessageDetailsParticipantFormatter, private val folderNameFormatter: FolderNameFormatter, )</ID>
-    <ID>LongParameterList:MessageListAdapterTest.kt$MessageListAdapterTest$( account: Account = Account(SOME_ACCOUNT_UUID), subject: String? = "irrelevant", threadCount: Int = 0, messageDate: Long = 0L, internalDate: Long = 0L, displayName: CharSequence = "irrelevant", displayAddress: Address? = Address.parse("irrelevant@domain.example").first(), previewText: String = "irrelevant", isMessageEncrypted: Boolean = false, isRead: Boolean = false, isStarred: Boolean = false, isAnswered: Boolean = false, isForwarded: Boolean = false, hasAttachments: Boolean = false, uniqueId: Long = 0L, folderId: Long = 0L, messageUid: String = "irrelevant", databaseId: Long = 0L, threadRoot: Long = 0L, )</ID>
-    <ID>LongParameterList:MessageListAdapterTest.kt$MessageListAdapterTest$( fontSizes: FontSizes = createFontSizes(), previewLines: Int = 0, stars: Boolean = true, senderAboveSubject: Boolean = false, showContactPicture: Boolean = true, showingThreadedList: Boolean = true, backGroundAsReadIndicator: Boolean = false, showAccountChip: Boolean = false, density: UiDensity = UiDensity.Default, )</ID>
-    <ID>LongParameterList:MessagePartDatabaseHelpers.kt$( type: Int = MessagePartType.UNKNOWN, root: Long? = null, parent: Long = -1, seq: Int = 0, mimeType: String? = null, decodedBodySize: Int? = null, displayName: String? = null, header: String? = null, encoding: String? = null, charset: String? = null, dataLocation: Int = DataLocation.MISSING, data: ByteArray? = null, preamble: String? = null, epilogue: String? = null, boundary: String? = null, contentId: String? = null, serverExtra: String? = null, )</ID>
     <ID>LongParameterList:PasswordPromptDialogFragment.kt$PasswordPromptDialogFragment.Companion$( accountUuid: String, accountName: String, inputIncomingServerPassword: Boolean, incomingServerName: String?, inputOutgoingServerPassword: Boolean, outgoingServerName: String?, targetFragment: Fragment, requestCode: Int, )</ID>
     <ID>LongParameterList:PushController.kt$PushController$( private val preferences: Preferences, private val generalSettingsManager: GeneralSettingsManager, private val backendManager: BackendManager, private val pushServiceManager: PushServiceManager, private val bootCompleteManager: BootCompleteManager, private val autoSyncManager: AutoSyncManager, private val pushNotificationManager: PushNotificationManager, private val connectivityManager: ConnectivityManager, private val accountPushControllerFactory: AccountPushControllerFactory, private val coroutineScope: CoroutineScope = GlobalScope, private val coroutineDispatcher: CoroutineDispatcher = Executors.newSingleThreadExecutor().asCoroutineDispatcher(), )</ID>
     <ID>LongParameterList:RecipientPresenter.kt$RecipientPresenter$( private val context: Context, loaderManager: LoaderManager, private val openPgpApiManager: OpenPgpApiManager, private val recipientMvpView: RecipientMvpView, account: Account, private val composePgpInlineDecider: ComposePgpInlineDecider, private val composePgpEnableByDefaultDecider: ComposePgpEnableByDefaultDecider, private val autocryptStatusInteractor: AutocryptStatusInteractor, private val replyToParser: ReplyToParser, private val draftStateHeaderParser: AutocryptDraftStateHeaderParser, )</ID>
-    <ID>LongParameterList:SaveMessageOperationsTest.kt$SaveMessageOperationsTest$( subject: String? = getSubject(), date: Long = sentDate?.time ?: System.currentTimeMillis(), internalDate: Long = date, downloadState: MessageDownloadState = getDownloadState(), attachmentCount: Int = 0, previewResult: PreviewResult = PreviewResult.none(), textForSearchIndex: String? = null, encryptionType: String? = null, )</ID>
     <ID>LongParameterList:SettingsImportViewModel.kt$SavedAccountState$( val accountIndex: Int, val displayName: String, val accountUuid: String, val selected: Boolean, val importStatus: ImportStatus, val incomingServerName: String?, val outgoingServerName: String?, val incomingServerPasswordNeeded: Boolean, val outgoingServerPasswordNeeded: Boolean, )</ID>
-    <ID>LoopWithTooManyJumpStatements:AccountSetupCheckSettings.kt$AccountSetupCheckSettings$for (subjectAlternativeName in subjectAlternativeNames) { val type = subjectAlternativeName[0] as Int val value: Any? = subjectAlternativeName[1] val name: String = when (type) { 0 -&gt; { Timber.w("SubjectAltName of type OtherName not supported.") continue } 1 -&gt; value as String 2 -&gt; value as String 3 -&gt; { Timber.w("unsupported SubjectAltName of type x400Address") continue } 4 -&gt; { Timber.w("unsupported SubjectAltName of type directoryName") continue } 5 -&gt; { Timber.w("unsupported SubjectAltName of type ediPartyName") continue } 6 -&gt; value as String 7 -&gt; value as String else -&gt; { Timber.w("unsupported SubjectAltName of unknown type") continue } } // if some of the SubjectAltNames match the store or transport -host, display them if (name.equals(incomingServerHost, ignoreCase = true) || name.equals(outgoingServerHost, ignoreCase = true) ) { // TODO: localize this string altNamesText.append("Subject(alt): ").append(name).append(",...\n") } else if (name.startsWith("*.") &amp;&amp; ( incomingServerHost.endsWith(name.substring(2)) || outgoingServerHost.endsWith(name.substring(2)) ) ) { // TODO: localize this string altNamesText.append("Subject(alt): ").append(name).append(",...\n") } }</ID>
-    <ID>LoopWithTooManyJumpStatements:HttpUriParser.kt$HttpUriParser$while (currentPos &lt; text.length) { val c = text[currentPos] if (isHexDigit(c)) { shouldBeHex = (shouldBeHex - 1).coerceAtLeast(0) } else if (shouldBeHex == 0) { if (c in allowedCharacters) { // Everything ok here :) } else if (c == '%') { shouldBeHex = 2 } else { break } } else { break } currentPos++ }</ID>
-    <ID>LoopWithTooManyJumpStatements:RealImapStore.kt$RealImapStore$for (listResponse in listResponses) { val serverId = listResponse.name if (pathDelimiter == null) { pathDelimiter = listResponse.hierarchyDelimiter combinedPrefix = null } if (RealImapFolder.INBOX.equals(serverId, ignoreCase = true)) { continue } else if (listResponse.hasAttribute("\\NoSelect")) { continue } val name = getFolderDisplayName(serverId) val oldServerId = getOldServerId(serverId) val type = when { listResponse.hasAttribute("\\Archive") -&gt; FolderType.ARCHIVE listResponse.hasAttribute("\\All") -&gt; FolderType.ARCHIVE listResponse.hasAttribute("\\Drafts") -&gt; FolderType.DRAFTS listResponse.hasAttribute("\\Sent") -&gt; FolderType.SENT listResponse.hasAttribute("\\Junk") -&gt; FolderType.SPAM listResponse.hasAttribute("\\Trash") -&gt; FolderType.TRASH else -&gt; FolderType.REGULAR } val existingItem = folderMap[serverId] if (existingItem == null || existingItem.type == FolderType.REGULAR) { folderMap[serverId] = FolderListItem(serverId, name, type, oldServerId) } }</ID>
-    <ID>LoopWithTooManyJumpStatements:SettingsExporter.kt$SettingsExporter$for ((key, value) in prefs) { val valueString = value.toString() val comps = key.split(".") if (comps.size &lt; 3) { // Skip non-identity config entries continue } val keyUuid = comps[0] val identityKey = comps[1] val identityIndex = comps[2] if (keyUuid != accountUuid || identityIndex != identity) { // Skip entries that belong to another identity continue } val versionedSetting = IdentitySettingsDescriptions.SETTINGS[identityKey] if (versionedSetting != null) { val highestVersion = versionedSetting.lastKey() val setting = versionedSetting[highestVersion] if (setting != null) { // Only write settings that have an entry in IdentitySettings.SETTINGS try { writeKeyAndPrettyValueFromSetting(serializer, identityKey, setting, valueString) } catch (e: InvalidSettingValueException) { Timber.w( "Identity setting \"%s\" has invalid value \"%s\" in preference storage. " + "This shouldn't happen!", identityKey, valueString, ) } } } }</ID>
-    <ID>LoopWithTooManyJumpStatements:SettingsExporter.kt$SettingsExporter$for ((key, value) in prefs) { val valueString = value.toString() val comps = key.split(".", limit = 2) if (comps.size &lt; 2) { // Skip global settings continue } val keyUuid = comps[0] val keyPart = comps[1] if (keyUuid != accountUuid) { // Setting doesn't belong to the account we're currently writing. continue } val indexOfLastDot = keyPart.lastIndexOf(".") val hasThirdPart = indexOfLastDot != -1 &amp;&amp; indexOfLastDot &lt; keyPart.length - 1 if (hasThirdPart) { val secondPart = keyPart.substring(0, indexOfLastDot) val thirdPart = keyPart.substring(indexOfLastDot + 1) if (secondPart == IDENTITY_DESCRIPTION_KEY) { // This is an identity key. Save identity index for later... thirdPart.toIntOrNull()?.let { identities.add(it) } // ... but don't write it now. continue } if (FolderSettingsDescriptions.SETTINGS.containsKey(thirdPart)) { // This is a folder key. Ignore it. continue } } if (keyPart !in FOLDER_NAME_KEYS) { writeAccountSettingIfValid(serializer, keyPart, valueString, account) } }</ID>
-    <ID>LoopWithTooManyJumpStatements:UnreadWidgetMigrations.kt$UnreadWidgetMigrations$for (widgetId in widgetIds) { val accountUuid = preferences.getString("unread_widget.$widgetId", null) ?: continue val account = accountRepository.getAccount(accountUuid) ?: continue val folderServerId = preferences.getString("unread_widget.$widgetId.folder_name", null) if (folderServerId != null) { val folderId = folderRepository.getFolderId(account, folderServerId) putString("unread_widget.$widgetId.folder_id", folderId?.toString()) } remove("unread_widget.$widgetId.folder_name") }</ID>
+    <ID>LoopWithTooManyJumpStatements:AccountSetupCheckSettings.kt$AccountSetupCheckSettings$for</ID>
+    <ID>LoopWithTooManyJumpStatements:HttpUriParser.kt$HttpUriParser$while</ID>
+    <ID>LoopWithTooManyJumpStatements:RealImapStore.kt$RealImapStore$for</ID>
+    <ID>LoopWithTooManyJumpStatements:SettingsExporter.kt$SettingsExporter$for</ID>
+    <ID>LoopWithTooManyJumpStatements:UnreadWidgetMigrations.kt$UnreadWidgetMigrations$for</ID>
     <ID>MagicNumber:Account.kt$Account$168</ID>
     <ID>MagicNumber:Account.kt$Account$2</ID>
     <ID>MagicNumber:Account.kt$Account$28</ID>
@@ -159,12 +156,12 @@
     <ID>MagicNumber:Account.kt$Account$6</ID>
     <ID>MagicNumber:Account.kt$Account$84</ID>
     <ID>MagicNumber:Account.kt$Account.DeletePolicy.MARK_AS_READ$3</ID>
-    <ID>MagicNumber:AccountCreator.kt$AccountCreator$110</ID>
-    <ID>MagicNumber:AccountCreator.kt$AccountCreator$143</ID>
-    <ID>MagicNumber:AccountCreator.kt$AccountCreator$465</ID>
-    <ID>MagicNumber:AccountCreator.kt$AccountCreator$587</ID>
-    <ID>MagicNumber:AccountCreator.kt$AccountCreator$993</ID>
-    <ID>MagicNumber:AccountCreator.kt$AccountCreator$995</ID>
+    <ID>MagicNumber:AccountCreatorHelper.kt$AccountCreatorHelper$110</ID>
+    <ID>MagicNumber:AccountCreatorHelper.kt$AccountCreatorHelper$143</ID>
+    <ID>MagicNumber:AccountCreatorHelper.kt$AccountCreatorHelper$465</ID>
+    <ID>MagicNumber:AccountCreatorHelper.kt$AccountCreatorHelper$587</ID>
+    <ID>MagicNumber:AccountCreatorHelper.kt$AccountCreatorHelper$993</ID>
+    <ID>MagicNumber:AccountCreatorHelper.kt$AccountCreatorHelper$995</ID>
     <ID>MagicNumber:AccountItem.kt$AccountItem$200L</ID>
     <ID>MagicNumber:AccountPreferenceSerializer.kt$AccountPreferenceSerializer$10</ID>
     <ID>MagicNumber:AccountPreferenceSerializer.kt$AccountPreferenceSerializer$24</ID>
@@ -279,7 +276,6 @@
     <ID>MagicNumber:MimeHeaderParser.kt$MimeHeaderParser$4</ID>
     <ID>MagicNumber:MimeParameterDecoder.kt$MimeParameterDecoder$3</ID>
     <ID>MagicNumber:MimeParameterEncoder.kt$MimeParameterEncoder$126</ID>
-    <ID>MagicNumber:MimeParameterEncoder.kt$MimeParameterEncoder$16</ID>
     <ID>MagicNumber:MimeParameterEncoder.kt$MimeParameterEncoder$3</ID>
     <ID>MagicNumber:MimeParameterEncoder.kt$MimeParameterEncoder$33</ID>
     <ID>MagicNumber:MimeParameterEncoder.kt$MimeParameterEncoder$35</ID>
@@ -443,7 +439,6 @@
     <ID>MatchingDeclarationName:Main.kt$HtmlCleaner : CliktCommand</ID>
     <ID>MaxLineLength:BoundaryGeneratorTest.kt$BoundaryGeneratorTest$0</ID>
     <ID>MaxLineLength:ComposeCryptoStatus.kt$ComposeCryptoStatus$OpenPgpApiManager.OpenPgpProviderState.ERROR, OpenPgpApiManager.OpenPgpProviderState.UI_REQUIRED -&gt; CryptoStatusDisplayType.ERROR</ID>
-    <ID>MaxLineLength:EmailAddressValidatorTest.kt$EmailAddressValidatorTest$Assert.assertTrue(validator.isValidAddressOnly("\"very.(),:;&lt;&gt;[]\\\".VERY.\\\"very@\\\\ \\\"very\\\".unusual\"@strange.example.com"))</ID>
     <ID>MaxLineLength:GenericUriParserTest.kt$GenericUriParserTest$assertUriValid("xmpp:node@example.com/repulsive%20!%23%22\$%25&amp;'()*+,-.%2F:;%3C=%3E%3F%40%5B%5C%5D%5E_%60%7B%7C%7D~resource")</ID>
     <ID>MaxLineLength:HtmlSanitizerTest.kt$HtmlSanitizerTest$assertThat(result.toCompactString()).isEqualTo("&lt;html&gt;&lt;head&gt;&lt;style&gt;keep this&lt;/style&gt;&lt;/head&gt;&lt;body&gt;&lt;/body&gt;&lt;/html&gt;")</ID>
     <ID>MaxLineLength:ImapSync.kt$ImapSync.&lt;no name provided&gt;$// TODO: This might be the source of poll count errors in the UI. Is todo always the same as ofTotal</ID>
@@ -461,7 +456,6 @@
     <ID>MayBeConst:SummaryNotificationDataCreatorTest.kt$private val TIMESTAMP = 0L</ID>
     <ID>MemberNameEqualsClassName:HtmlModification.kt$HtmlModification.Replace$abstract fun replace(textToHtml: TextToHtml)</ID>
     <ID>MemberNameEqualsClassName:ReplyToView.kt$ReplyToView$private val replyToView: RecipientSelectView = activity.findViewById(R.id.reply_to)</ID>
-    <ID>NestedBlockDepth:AutoconfigParser.kt$AutoconfigParser$private fun parseServer(xpp: XmlPullParser, nodeName: String, email: String): DiscoveredServerSettings</ID>
     <ID>NestedBlockDepth:HttpUriParser.kt$HttpUriParser$private fun tryMatchIpv6Address(text: CharSequence, startPos: Int): Int</ID>
     <ID>NestedBlockDepth:ImapSync.kt$ImapSync$private fun synchronizeMailboxSynchronous(folder: String, syncConfig: SyncConfig, listener: SyncListener)</ID>
     <ID>NestedBlockDepth:MessageList.kt$MessageList$override fun onBackPressed()</ID>
@@ -567,14 +561,12 @@
     <ID>SpreadOperator:ReplyToView.kt$ReplyToView$(*recipients)</ID>
     <ID>SwallowedException:AboutFragment.kt$e: ActivityNotFoundException</ID>
     <ID>SwallowedException:AuthViewModel.kt$AuthViewModel$e: ActivityNotFoundException</ID>
-    <ID>SwallowedException:CommandRefreshFolderListTest.kt$CommandRefreshFolderListTest$e: AuthenticationFailedException</ID>
     <ID>SwallowedException:ContactPictureLoader.kt$ContactPictureLoader$e: Exception</ID>
     <ID>SwallowedException:DecoderUtil.kt$DecoderUtil$e: IOException</ID>
     <ID>SwallowedException:DecoderUtil.kt$DecoderUtil$e: MessagingException</ID>
     <ID>SwallowedException:JmapAccountDiscovery.kt$JmapAccountDiscovery$e: EndpointNotFoundException</ID>
     <ID>SwallowedException:JmapAccountDiscovery.kt$JmapAccountDiscovery$e: UnauthorizedException</ID>
     <ID>SwallowedException:JmapAccountDiscovery.kt$JmapAccountDiscovery$e: UnknownHostException</ID>
-    <ID>SwallowedException:K9BackendFolderTest.kt$K9BackendFolderTest$e: IllegalStateException</ID>
     <ID>SwallowedException:LocalKeyStore.kt$LocalKeyStore$e: FileNotFoundException</ID>
     <ID>SwallowedException:LocalKeyStore.kt$LocalKeyStore$e: KeyStoreException</ID>
     <ID>SwallowedException:MessageContainerView.kt$MessageContainerView$e: ActivityNotFoundException</ID>
@@ -588,8 +580,6 @@
     <ID>SwallowedException:MimeParameterDecoder.kt$MimeParameterDecoder$e: IllegalCharsetNameException</ID>
     <ID>SwallowedException:MimeParameterDecoder.kt$MimeParameterDecoder$e: MimeHeaderParserException</ID>
     <ID>SwallowedException:MimeType.kt$MimeType.Companion$e: IllegalArgumentException</ID>
-    <ID>SwallowedException:PgpMessageBuilderTest.kt$PgpMessageBuilderTest.Companion$e: IOException</ID>
-    <ID>SwallowedException:PgpMessageBuilderTest.kt$PgpMessageBuilderTest.Companion$e: MessagingException</ID>
     <ID>SwallowedException:PushInfoFragment.kt$PushInfoFragment$e: ActivityNotFoundException</ID>
     <ID>SwallowedException:QuoteDateFormatter.kt$QuoteDateFormatter$e: Exception</ID>
     <ID>SwallowedException:RealImapConnection.kt$RealImapConnection$e: NegativeImapResponseException</ID>
@@ -600,7 +590,6 @@
     <ID>SwallowedException:SettingsExporter.kt$SettingsExporter$e: InvalidSettingValueException</ID>
     <ID>SwallowedException:SettingsListFragment.kt$SettingsListFragment$e: ActivityNotFoundException</ID>
     <ID>SwallowedException:SmtpTransport.kt$SmtpTransport$e: NegativeSmtpReplyException</ID>
-    <ID>SwallowedException:SmtpTransport.kt$SmtpTransport$exception: NegativeSmtpReplyException</ID>
     <ID>ThrowingExceptionsWithoutMessageOrCause:RealImapConnection.kt$RealImapConnection$Exception()</ID>
     <ID>ThrowingExceptionsWithoutMessageOrCause:SmtpTransport.kt$SmtpTransport$RuntimeException()</ID>
     <ID>ThrowingExceptionsWithoutMessageOrCause:TimberLogger.kt$TimberLogger$Throwable()</ID>
@@ -610,7 +599,6 @@
     <ID>ThrowsCount:RealImapConnection.kt$RealImapConnection$private fun authenticate(): List&lt;ImapResponse&gt;</ID>
     <ID>ThrowsCount:SmtpTransport.kt$SmtpTransport$@Throws(MessagingException::class) fun sendMessage(message: Message)</ID>
     <ID>ThrowsCount:SmtpTransport.kt$SmtpTransport$@VisibleForTesting @Throws(MessagingException::class) internal fun open()</ID>
-    <ID>ThrowsCount:SmtpTransport.kt$SmtpTransport$private fun saslAuthCramMD5()</ID>
     <ID>TooGenericExceptionCaught:AccountRemover.kt$AccountRemover$e: Exception</ID>
     <ID>TooGenericExceptionCaught:AccountSetupCheckSettings.kt$AccountSetupCheckSettings$e: Exception</ID>
     <ID>TooGenericExceptionCaught:AccountSetupCheckSettings.kt$AccountSetupCheckSettings.CheckAccountTask$e: Exception</ID>
@@ -750,15 +738,11 @@
     <ID>TooManyFunctions:UnreadWidgetConfigurationFragment.kt$UnreadWidgetConfigurationFragment : PreferenceFragmentCompat</ID>
     <ID>TooManyFunctions:UpdateFolderOperations.kt$UpdateFolderOperations</ID>
     <ID>TooManyFunctions:VibrationDialogFragment.kt$VibrationDialogFragment$VibrationPatternAdapter : BaseAdapter</ID>
-    <ID>UnnecessaryAbstractClass:AppRobolectricTest.kt$AppRobolectricTest$AppRobolectricTest</ID>
-    <ID>UnnecessaryAbstractClass:HtmlModification.kt$HtmlModification$HtmlModification</ID>
-    <ID>UnnecessaryAbstractClass:K9RobolectricTest.kt$K9RobolectricTest$K9RobolectricTest</ID>
-    <ID>UnnecessaryAbstractClass:RobolectricTest.kt$RobolectricTest$RobolectricTest</ID>
-    <ID>UnusedPrivateMember:Contacts.kt$Contacts$addresses: Array&lt;Address?&gt;?</ID>
-    <ID>UnusedPrivateMember:ExtraAccountDiscovery.kt$ExtraAccountDiscovery$email: String</ID>
-    <ID>UnusedPrivateMember:HttpUriParser.kt$HttpUriParser$i</ID>
-    <ID>UnusedPrivateMember:MessageListLoader.kt$MessageListLoader$account: Account</ID>
-    <ID>UnusedPrivateMember:MessageViewFragment.kt$MessageViewFragment$requestKey: String</ID>
+    <ID>UnusedParameter:Contacts.kt$Contacts$addresses: Array&lt;Address?&gt;?</ID>
+    <ID>UnusedParameter:ExtraAccountDiscovery.kt$ExtraAccountDiscovery$email: String</ID>
+    <ID>UnusedParameter:MessageListLoader.kt$MessageListLoader$account: Account</ID>
+    <ID>UnusedParameter:MessageViewFragment.kt$MessageViewFragment$requestKey: String</ID>
+    <ID>UnusedPrivateProperty:HttpUriParser.kt$HttpUriParser$i</ID>
     <ID>UseCheckOrError:OutboxStateRepository.kt$OutboxStateRepository$throw IllegalStateException("No outbox_state entry for message with id $messageId")</ID>
     <ID>UseCheckOrError:ThemeExtensions.kt$throw IllegalStateException("Couldn't resolve attribute ($attrId)")</ID>
     <ID>UseRequire:MimeParameterEncoder.kt$MimeParameterEncoder$throw IllegalArgumentException("Unsupported character: $c")</ID>
diff --git a/config/detekt/detekt.yml b/config/detekt/detekt.yml
index 5ef70fc8cdede6e6cdd0170f7a1af528a072f1f0..dc234b9049051442386d32465dc7a929440b7d8e 100644
--- a/config/detekt/detekt.yml
+++ b/config/detekt/detekt.yml
@@ -48,6 +48,7 @@ output-reports:
   # - 'XmlOutputReport'
   # - 'HtmlOutputReport'
   # - 'MdOutputReport'
+  # - 'SarifOutputReport'
 
 comments:
   active: true
@@ -66,7 +67,7 @@ comments:
     endOfSentenceFormat: '([.?!][ \t\n\r\f<])|([.?!:]$)'
   KDocReferencesNonPublicProperty:
     active: false
-    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**']
+    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**']
   OutdatedDocumentation:
     active: false
     matchTypeParameters: true
@@ -74,7 +75,7 @@ comments:
     allowParamOnConstructorProperties: false
   UndocumentedPublicClass:
     active: false
-    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**']
+    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**']
     searchInNestedClass: true
     searchInInnerClass: true
     searchInInnerObject: true
@@ -82,11 +83,11 @@ comments:
     searchInProtectedClass: false
   UndocumentedPublicFunction:
     active: false
-    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**']
+    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**']
     searchProtectedFunction: false
   UndocumentedPublicProperty:
     active: false
-    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**']
+    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**']
     searchProtectedProperty: false
 
 complexity:
@@ -132,7 +133,7 @@ complexity:
     active: true
     functionThreshold: 8
     constructorThreshold: 8
-    ignoreDefaultParameters: false
+    ignoreDefaultParameters: true
     ignoreDataClasses: true
     ignoreAnnotatedParameter: []
   MethodOverloading:
@@ -158,14 +159,14 @@ complexity:
     active: false
   StringLiteralDuplication:
     active: false
-    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**']
+    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**']
     threshold: 3
     ignoreAnnotation: true
     excludeStringsWithLessThan5Characters: true
     ignoreStringsRegex: '$^'
   TooManyFunctions:
     active: true
-    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**']
+    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**']
     thresholdInFiles: 11
     thresholdInClasses: 11
     thresholdInInterfaces: 11
@@ -189,6 +190,8 @@ coroutines:
     active: true
   SleepInsteadOfDelay:
     active: true
+  SuspendFunSwallowedCancellation:
+    active: false
   SuspendFunWithCoroutineScopeReceiver:
     active: false
   SuspendFunWithFlowReturnType:
@@ -240,7 +243,7 @@ exceptions:
       - 'toString'
   InstanceOfCheckForException:
     active: true
-    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**']
+    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**']
   NotImplementedDeclaration:
     active: false
   ObjectExtendsThrowable:
@@ -266,7 +269,7 @@ exceptions:
     active: false
   ThrowingExceptionsWithoutMessageOrCause:
     active: true
-    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**']
+    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**']
     exceptions:
       - 'ArrayIndexOutOfBoundsException'
       - 'Exception'
@@ -281,7 +284,7 @@ exceptions:
     active: true
   TooGenericExceptionCaught:
     active: true
-    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**']
+    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**']
     exceptionNames:
       - 'ArrayIndexOutOfBoundsException'
       - 'Error'
@@ -305,7 +308,6 @@ naming:
   BooleanPropertyNaming:
     active: false
     allowedPattern: '^(is|has|are)'
-    ignoreOverridden: true
   ClassNaming:
     active: true
     classPattern: '[A-Z][a-zA-Z0-9]*'
@@ -314,7 +316,6 @@ naming:
     parameterPattern: '[a-z][A-Za-z0-9]*'
     privateParameterPattern: '[a-z][A-Za-z0-9]*'
     excludeClassPattern: '$^'
-    ignoreOverridden: true
   EnumNaming:
     active: true
     enumEntryPattern: '[A-Z][_a-zA-Z0-9]*'
@@ -329,17 +330,15 @@ naming:
     minimumFunctionNameLength: 3
   FunctionNaming:
     active: true
-    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**']
+    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**']
     functionPattern: '[a-z][a-zA-Z0-9]*'
     excludeClassPattern: '$^'
-    ignoreOverridden: true
     ignoreAnnotated:
       - 'Composable'
   FunctionParameterNaming:
     active: true
     parameterPattern: '[a-z][A-Za-z0-9]*'
     excludeClassPattern: '$^'
-    ignoreOverridden: true
   InvalidPackageDeclaration:
     active: true
     rootPackage: ''
@@ -381,7 +380,6 @@ naming:
     variablePattern: '[a-z][A-Za-z0-9]*'
     privateVariablePattern: '(_)?[a-z][A-Za-z0-9]*'
     excludeClassPattern: '$^'
-    ignoreOverridden: true
 
 performance:
   active: true
@@ -392,10 +390,10 @@ performance:
     threshold: 3
   ForEachOnRange:
     active: true
-    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**']
+    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**']
   SpreadOperator:
     active: true
-    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**']
+    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**']
   UnnecessaryPartOfBinaryExpression:
     active: false
   UnnecessaryTemporaryInstantiation:
@@ -407,8 +405,10 @@ potential-bugs:
     active: true
     forbiddenTypePatterns:
       - 'kotlin.String'
+  CastNullableToNonNullableType:
+    active: true
   CastToNullableType:
-    active: false
+    active: true
   Deprecation:
     active: false
   DontDowncastCollectionTypes:
@@ -426,6 +426,7 @@ potential-bugs:
       - 'java.util.HashMap'
   ElseCaseInsteadOfExhaustiveWhen:
     active: false
+    ignoredSubjectTypes: []
   EqualsAlwaysReturnsTrueOrFalse:
     active: true
   EqualsWithHashCodeExist:
@@ -440,9 +441,12 @@ potential-bugs:
     active: true
     restrictToConfig: true
     returnValueAnnotations:
+      - 'CheckResult'
       - '*.CheckResult'
+      - 'CheckReturnValue'
       - '*.CheckReturnValue'
     ignoreReturnValueAnnotations:
+      - 'CanIgnoreReturnValue'
       - '*.CanIgnoreReturnValue'
     returnValueTypes:
       - 'kotlin.sequences.Sequence'
@@ -462,7 +466,7 @@ potential-bugs:
     active: true
   LateinitUsage:
     active: false
-    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**']
+    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**']
     ignoreOnClassesPattern: ''
   MapGetWithNotNullAssertionOperator:
     active: true
@@ -473,6 +477,8 @@ potential-bugs:
     active: false
   NullableToStringCall:
     active: false
+  PropertyUsedBeforeDeclaration:
+    active: false
   UnconditionalJumpStatementInLoop:
     active: false
   UnnecessaryNotNullCheck:
@@ -487,7 +493,7 @@ potential-bugs:
     active: true
   UnsafeCallOnNullableType:
     active: true
-    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**']
+    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**']
   UnsafeCast:
     active: true
   UnusedUnaryOperator:
@@ -501,6 +507,14 @@ style:
   active: true
   AlsoCouldBeApply:
     active: false
+  BracesOnIfStatements:
+    active: false
+    singleLine: 'never'
+    multiLine: 'always'
+  BracesOnWhenStatements:
+    active: false
+    singleLine: 'necessary'
+    multiLine: 'consistent'
   CanBeNonNullable:
     active: false
   CascadingCallWrapping:
@@ -514,11 +528,22 @@ style:
     active: false
     conversionFunctionPrefix:
       - 'to'
+    allowOperators: false
   DataClassShouldBeImmutable:
     active: false
   DestructuringDeclarationWithTooManyEntries:
     active: true
     maxDestructuringEntries: 3
+  DoubleNegativeLambda:
+    active: false
+    negativeFunctions:
+      - reason: 'Use `takeIf` instead.'
+        value: 'takeUnless'
+      - reason: 'Use `all` instead.'
+        value: 'none'
+    negativeFunctionNameParts:
+      - 'not'
+      - 'non'
   EqualsNullCall:
     active: true
   EqualsOnSignatureLine:
@@ -530,13 +555,31 @@ style:
   ExpressionBodySyntax:
     active: false
     includeLineWrapping: false
+  ForbiddenAnnotation:
+    active: false
+    annotations:
+      - reason: 'it is a java annotation. Use `Suppress` instead.'
+        value: 'java.lang.SuppressWarnings'
+      - reason: 'it is a java annotation. Use `kotlin.Deprecated` instead.'
+        value: 'java.lang.Deprecated'
+      - reason: 'it is a java annotation. Use `kotlin.annotation.MustBeDocumented` instead.'
+        value: 'java.lang.annotation.Documented'
+      - reason: 'it is a java annotation. Use `kotlin.annotation.Target` instead.'
+        value: 'java.lang.annotation.Target'
+      - reason: 'it is a java annotation. Use `kotlin.annotation.Retention` instead.'
+        value: 'java.lang.annotation.Retention'
+      - reason: 'it is a java annotation. Use `kotlin.annotation.Repeatable` instead.'
+        value: 'java.lang.annotation.Repeatable'
+      - reason: 'Kotlin does not support @Inherited annotation, see https://youtrack.jetbrains.com/issue/KT-22265'
+        value: 'java.lang.annotation.Inherited'
   ForbiddenComment:
     active: true
-    values:
-      - 'FIXME:'
-      - 'STOPSHIP:'
+    comments:
+      - reason: 'Forbidden FIXME todo marker in comment, please fix the problem.'
+        value: 'FIXME:'
+      - reason: 'Forbidden STOPSHIP todo marker in comment, please address the problem before shipping the code.'
+        value: 'STOPSHIP:'
     allowedPatterns: ''
-    customMessage: ''
   ForbiddenImport:
     active: false
     imports: []
@@ -565,7 +608,7 @@ style:
     maxJumpCount: 1
   MagicNumber:
     active: true
-    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/jsTest/**', '**/iosTest/**', '**/*.kts']
+    excludes: ['**/test/**', '**/androidTest/**', '**/commonTest/**', '**/jvmTest/**', '**/androidUnitTest/**', '**/androidInstrumentedTest/**', '**/jsTest/**', '**/iosTest/**', '**/*.kts']
     ignoreNumbers:
       - '-1'
       - '0'
@@ -583,8 +626,6 @@ style:
     ignoreEnums: false
     ignoreRanges: false
     ignoreExtensionFunctions: true
-  MandatoryBracesIfStatements:
-    active: false
   MandatoryBracesLoops:
     active: false
   MaxChainedCallsOnSameLine:
@@ -606,6 +647,9 @@ style:
   MultilineRawStringIndentation:
     active: false
     indentSize: 4
+    trimmingMethods:
+      - 'trimIndent'
+      - 'trimMargin'
   NestedClassesVisibility:
     active: true
   NewLineAtEndOfFile:
@@ -646,6 +690,10 @@ style:
     active: true
   SpacingBetweenPackageAndImports:
     active: false
+  StringShouldBeRawString:
+    active: false
+    maxEscapedCharacterCount: 2
+    ignoredCharacters: []
   ThrowsCount:
     active: true
     max: 2
@@ -654,6 +702,9 @@ style:
     active: false
   TrimMultilineRawString:
     active: false
+    trimmingMethods:
+      - 'trimIndent'
+      - 'trimMargin'
   UnderscoresInNumericLiterals:
     active: false
     acceptableLength: 4
@@ -666,6 +717,8 @@ style:
     active: true
   UnnecessaryBackticks:
     active: false
+  UnnecessaryBracesAroundTrailingLambda:
+    active: false
   UnnecessaryFilter:
     active: true
   UnnecessaryInheritance:
@@ -681,11 +734,17 @@ style:
     active: false
   UnusedImports:
     active: false
+  UnusedParameter:
+    active: true
+    allowedNames: 'ignored|expected'
   UnusedPrivateClass:
     active: true
   UnusedPrivateMember:
     active: true
-    allowedNames: '(_|ignored|expected|serialVersionUID)'
+    allowedNames: ''
+  UnusedPrivateProperty:
+    active: true
+    allowedNames: '_|ignored|expected|serialVersionUID'
     ignoreAnnotated:
       - 'Preview'
   UseAnyOrNoneInsteadOfFind:
@@ -705,8 +764,11 @@ style:
     active: false
   UseIfInsteadOfWhen:
     active: false
+    ignoreWhenContainingVariableDeclaration: false
   UseIsNullOrEmpty:
     active: true
+  UseLet:
+    active: false
   UseOrEmpty:
     active: true
   UseRequire:
@@ -730,11 +792,9 @@ style:
 Compose:
   CompositionLocalAllowlist:
     active: true
-    allowedCompositionLocals: [LocalColors, LocalElevations, LocalImages, LocalSizes, LocalSpacings]
+    allowedCompositionLocals: [LocalColors, LocalElevations, LocalImages, LocalShapes, LocalSizes, LocalSpacings, LocalActivity]
   ContentEmitterReturningValues:
     active: true
-    # You can optionally add your own composables here
-    # contentEmitters: MyComposable,MyOtherComposable
   ModifierComposable:
     active: true
   ModifierMissing:
@@ -745,22 +805,16 @@ Compose:
     active: true
   MultipleEmitters:
     active: true
-      # You can optionally add your own composables here
-    # contentEmitters: MyComposable,MyOtherComposable
   MutableParams:
     active: true
   ComposableNaming:
     active: true
-    # You can optionally disable the checks in this rule for regex matches against the composable name (e.g. molecule presenters)
-    # allowedComposableFunctionNames: .*Presenter,.*MoleculePresenter
   ComposableParamOrder:
     active: true
   PreviewNaming:
     active: true
   PreviewPublic:
     active: true
-    # You can optionally disable that only previews with @PreviewParameter are flagged
-    # previewPublicOnlyIfParams: false
   RememberMissing:
     active: true
   UnstableCollections:
@@ -769,4 +823,3 @@ Compose:
     active: true
   ViewModelInjection:
     active: true
-
diff --git a/core/android/common/src/test/kotlin/app/k9mail/core/android/common/CoreCommonAndroidModuleKtTest.kt b/core/android/common/src/test/kotlin/app/k9mail/core/android/common/CoreCommonAndroidModuleKtTest.kt
index 5d1a3d7f308f4f5432f33f9cd18b6d6dd1800a37..a300b5e5f35c9fb76db942fc87f9ab6924d5e81c 100644
--- a/core/android/common/src/test/kotlin/app/k9mail/core/android/common/CoreCommonAndroidModuleKtTest.kt
+++ b/core/android/common/src/test/kotlin/app/k9mail/core/android/common/CoreCommonAndroidModuleKtTest.kt
@@ -1,5 +1,6 @@
 package app.k9mail.core.android.common
 
+import app.k9mail.core.android.common.test.externalModule
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.koin.android.ext.koin.androidContext
@@ -14,7 +15,10 @@ internal class CoreCommonAndroidModuleKtTest {
     @Test
     fun `should have a valid di module`() {
         koinApplication {
-            modules(coreCommonAndroidModule)
+            modules(
+                externalModule,
+                coreCommonAndroidModule,
+            )
             androidContext(RuntimeEnvironment.getApplication())
             checkModules()
         }
diff --git a/core/android/common/src/test/kotlin/app/k9mail/core/android/common/contact/ContactFixture.kt b/core/android/common/src/test/kotlin/app/k9mail/core/android/common/contact/ContactFixture.kt
index 600ca3168771c753ebb4686db247a50c448f1511..35567986af2319748aa3af0f1a77f0342dd6a5e7 100644
--- a/core/android/common/src/test/kotlin/app/k9mail/core/android/common/contact/ContactFixture.kt
+++ b/core/android/common/src/test/kotlin/app/k9mail/core/android/common/contact/ContactFixture.kt
@@ -1,12 +1,12 @@
 package app.k9mail.core.android.common.contact
 
 import android.net.Uri
-import app.k9mail.core.common.mail.EmailAddress
+import app.k9mail.core.common.mail.toEmailAddressOrThrow
 
 const val CONTACT_ID = 123L
 const val CONTACT_NAME = "user name"
 const val CONTACT_LOOKUP_KEY = "0r1-4F314D4F2F294F29"
-val CONTACT_EMAIL_ADDRESS = EmailAddress("user@example.com")
+val CONTACT_EMAIL_ADDRESS = "user@example.com".toEmailAddressOrThrow()
 val CONTACT_URI: Uri = Uri.parse("content://com.android.contacts/contacts/lookup/$CONTACT_LOOKUP_KEY/$CONTACT_ID")
 val CONTACT_PHOTO_URI: Uri = Uri.parse("content://com.android.contacts/display_photo/$CONTACT_ID")
 
diff --git a/core/android/common/src/test/kotlin/app/k9mail/core/android/common/contact/ContactKoinModuleKtTest.kt b/core/android/common/src/test/kotlin/app/k9mail/core/android/common/contact/ContactKoinModuleKtTest.kt
index 863a7d1e4389e1ef25bd37cc6a5c55220db86dd4..746d42bc6ff933babc47cca4ae0628ce2cdee779 100644
--- a/core/android/common/src/test/kotlin/app/k9mail/core/android/common/contact/ContactKoinModuleKtTest.kt
+++ b/core/android/common/src/test/kotlin/app/k9mail/core/android/common/contact/ContactKoinModuleKtTest.kt
@@ -1,6 +1,7 @@
 package app.k9mail.core.android.common.contact
 
 import app.k9mail.core.android.common.coreCommonAndroidModule
+import app.k9mail.core.android.common.test.externalModule
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.koin.android.ext.koin.androidContext
@@ -11,13 +12,15 @@ import org.robolectric.RuntimeEnvironment
 
 @RunWith(RobolectricTestRunner::class)
 internal class ContactKoinModuleKtTest {
+
     @Test
     fun `should have a valid di module`() {
         koinApplication {
-            modules(coreCommonAndroidModule)
-
-            modules(contactModule)
-
+            modules(
+                externalModule,
+                coreCommonAndroidModule,
+                contactModule,
+            )
             androidContext(RuntimeEnvironment.getApplication())
             checkModules()
         }
diff --git a/core/android/common/src/test/kotlin/app/k9mail/core/android/common/database/CursorExtensionsKtAccessTest.kt b/core/android/common/src/test/kotlin/app/k9mail/core/android/common/database/CursorExtensionsKtAccessTest.kt
index d228ae48c976c15fbf88afad0018bd92352f91f7..1eaa52f71c9bfbd83b079fd86ec92ba09a14cb7c 100644
--- a/core/android/common/src/test/kotlin/app/k9mail/core/android/common/database/CursorExtensionsKtAccessTest.kt
+++ b/core/android/common/src/test/kotlin/app/k9mail/core/android/common/database/CursorExtensionsKtAccessTest.kt
@@ -2,10 +2,10 @@ package app.k9mail.core.android.common.database
 
 import android.database.Cursor
 import android.database.MatrixCursor
+import assertk.assertFailure
 import assertk.assertThat
 import assertk.assertions.hasMessage
 import assertk.assertions.isEqualTo
-import assertk.assertions.isFailure
 import assertk.assertions.isNull
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -55,9 +55,9 @@ class CursorExtensionsKtAccessTest(data: CursorExtensionsAccessTestData<Any>) {
             addRow(arrayOf(null))
         }
 
-        assertThat {
+        assertFailure {
             cursor.map { testThrowingAction(it, "column") }
-        }.isFailure().hasMessage("Column column must not be null")
+        }.hasMessage("Column column must not be null")
     }
 
     @Test
diff --git a/core/android/common/src/test/kotlin/app/k9mail/core/android/common/test/GlobalSettingsModule.kt b/core/android/common/src/test/kotlin/app/k9mail/core/android/common/test/GlobalSettingsModule.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c9c2b217ce39f0c23fa44d56ce12b5ddef48a127
--- /dev/null
+++ b/core/android/common/src/test/kotlin/app/k9mail/core/android/common/test/GlobalSettingsModule.kt
@@ -0,0 +1,10 @@
+package app.k9mail.core.android.common.test
+
+import app.k9mail.core.common.oauth.OAuthConfigurationFactory
+import org.koin.dsl.module
+
+internal val externalModule = module {
+    single<OAuthConfigurationFactory> {
+        OAuthConfigurationFactory { emptyMap() }
+    }
+}
diff --git a/core/android/testing/build.gradle.kts b/core/android/testing/build.gradle.kts
new file mode 100644
index 0000000000000000000000000000000000000000..27f82be0152101a430c018da165581616f57730c
--- /dev/null
+++ b/core/android/testing/build.gradle.kts
@@ -0,0 +1,12 @@
+plugins {
+    id(ThunderbirdPlugins.Library.android)
+}
+
+android {
+    namespace = "app.k9mail.core.android.testing"
+}
+
+dependencies {
+    api(libs.junit)
+    api(libs.robolectric)
+}
diff --git a/app/testing/src/main/java/com/fsck/k9/RobolectricTest.kt b/core/android/testing/src/main/kotlin/app/k9mail/core/android/testing/RobolectricTest.kt
similarity index 82%
rename from app/testing/src/main/java/com/fsck/k9/RobolectricTest.kt
rename to core/android/testing/src/main/kotlin/app/k9mail/core/android/testing/RobolectricTest.kt
index 8dde7f563f4cfc7d60c1e3c514a3e88f70999428..79fec5f07f2aad4de538936e294e9a9c857c46e0 100644
--- a/app/testing/src/main/java/com/fsck/k9/RobolectricTest.kt
+++ b/core/android/testing/src/main/kotlin/app/k9mail/core/android/testing/RobolectricTest.kt
@@ -1,4 +1,4 @@
-package com.fsck.k9
+package app.k9mail.core.android.testing
 
 import android.app.Application
 import org.junit.runner.RunWith
@@ -6,9 +6,7 @@ import org.robolectric.RobolectricTestRunner
 import org.robolectric.annotation.Config
 
 /**
- * A Robolectric test that does not create an instance of our [Application] class [K9].
- *
- * See also [K9RobolectricTest].
+ * A Robolectric test that does not create an instance of our [Application].
  */
 @RunWith(RobolectricTestRunner::class)
 @Config(application = EmptyApplication::class)
diff --git a/core/common/src/main/kotlin/app/k9mail/core/common/CoreCommonModule.kt b/core/common/src/main/kotlin/app/k9mail/core/common/CoreCommonModule.kt
index b7c9075790ecf6fa759d95a455edf56d0080cefd..16832f85cb0dd05e4157518a381483e4f2ede388 100644
--- a/core/common/src/main/kotlin/app/k9mail/core/common/CoreCommonModule.kt
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/CoreCommonModule.kt
@@ -1,9 +1,17 @@
 package app.k9mail.core.common
 
+import app.k9mail.core.common.oauth.InMemoryOAuthConfigurationProvider
+import app.k9mail.core.common.oauth.OAuthConfigurationProvider
 import kotlinx.datetime.Clock
 import org.koin.core.module.Module
 import org.koin.dsl.module
 
 val coreCommonModule: Module = module {
     single<Clock> { Clock.System }
+
+    single<OAuthConfigurationProvider> {
+        InMemoryOAuthConfigurationProvider(
+            configurationFactory = get(),
+        )
+    }
 }
diff --git a/core/common/src/main/kotlin/app/k9mail/core/common/domain/usecase/validation/ValidationError.kt b/core/common/src/main/kotlin/app/k9mail/core/common/domain/usecase/validation/ValidationError.kt
new file mode 100644
index 0000000000000000000000000000000000000000..068cd486cd51035141bd5871f3fc52c49d6eecd1
--- /dev/null
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/domain/usecase/validation/ValidationError.kt
@@ -0,0 +1,3 @@
+package app.k9mail.core.common.domain.usecase.validation
+
+interface ValidationError
diff --git a/core/common/src/main/kotlin/app/k9mail/core/common/domain/usecase/validation/ValidationResult.kt b/core/common/src/main/kotlin/app/k9mail/core/common/domain/usecase/validation/ValidationResult.kt
new file mode 100644
index 0000000000000000000000000000000000000000..582cbe32165f1e1dd6922bec31a3ac8e9bb6966f
--- /dev/null
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/domain/usecase/validation/ValidationResult.kt
@@ -0,0 +1,7 @@
+package app.k9mail.core.common.domain.usecase.validation
+
+sealed interface ValidationResult {
+    object Success : ValidationResult
+
+    data class Failure(val error: ValidationError) : ValidationResult
+}
diff --git a/core/common/src/main/kotlin/app/k9mail/core/common/mail/AbstractParser.kt b/core/common/src/main/kotlin/app/k9mail/core/common/mail/AbstractParser.kt
new file mode 100644
index 0000000000000000000000000000000000000000..5d32e34bbb126c59a3afc0a4391dc2ad709ba82f
--- /dev/null
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/mail/AbstractParser.kt
@@ -0,0 +1,81 @@
+package app.k9mail.core.common.mail
+
+import app.k9mail.core.common.mail.EmailAddressParserError.UnexpectedCharacter
+import app.k9mail.core.common.mail.EmailAddressParserError.UnexpectedEndOfInput
+
+@Suppress("UnnecessaryAbstractClass")
+internal abstract class AbstractParser(val input: String, startIndex: Int = 0, val endIndex: Int = input.length) {
+    protected var currentIndex = startIndex
+
+    val position: Int
+        get() = currentIndex
+
+    fun endReached() = currentIndex >= endIndex
+
+    fun peek(): Char {
+        if (currentIndex >= endIndex) {
+            parserError(UnexpectedEndOfInput)
+        }
+
+        return input[currentIndex]
+    }
+
+    fun read(): Char {
+        if (currentIndex >= endIndex) {
+            parserError(UnexpectedEndOfInput)
+        }
+
+        return input[currentIndex].also { currentIndex++ }
+    }
+
+    fun expect(character: Char) {
+        if (!endReached() && peek() == character) {
+            currentIndex++
+        } else {
+            parserError(UnexpectedCharacter, message = "Expected '$character' (${character.code})")
+        }
+    }
+
+    @Suppress("SameParameterValue")
+    protected inline fun expect(displayInError: String, predicate: (Char) -> Boolean) {
+        if (!endReached() && predicate(peek())) {
+            skip()
+        } else {
+            parserError(UnexpectedCharacter, message = "Expected $displayInError")
+        }
+    }
+
+    @Suppress("NOTHING_TO_INLINE")
+    protected inline fun skip() {
+        currentIndex++
+    }
+
+    protected inline fun skipWhile(crossinline predicate: (Char) -> Boolean) {
+        while (!endReached() && predicate(input[currentIndex])) {
+            currentIndex++
+        }
+    }
+
+    protected inline fun readString(block: () -> Unit): String {
+        val startIndex = currentIndex
+        block()
+        return input.substring(startIndex, currentIndex)
+    }
+
+    protected inline fun <P : AbstractParser, T> withParser(parser: P, block: P.() -> T): T {
+        try {
+            return block(parser)
+        } finally {
+            currentIndex = parser.position
+        }
+    }
+
+    @Suppress("NOTHING_TO_INLINE")
+    protected inline fun parserError(
+        error: EmailAddressParserError,
+        position: Int = currentIndex,
+        message: String = error.message,
+    ): Nothing {
+        throw EmailAddressParserException(message, error, input, position)
+    }
+}
diff --git a/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailAddress.kt b/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailAddress.kt
index b6c3f1760b92d300d22e7aaf470191aa7097d3b4..cdf0dfd603e50497bcdd2da3a1eb4accae7ead65 100644
--- a/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailAddress.kt
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailAddress.kt
@@ -1,8 +1,138 @@
 package app.k9mail.core.common.mail
 
-@JvmInline
-value class EmailAddress(val address: String) {
+// See RFC 5321, 4.5.3.1.3.
+// The maximum length of 'Path' indirectly limits the length of 'Mailbox'.
+internal const val MAXIMUM_EMAIL_ADDRESS_LENGTH = 254
+
+// See RFC 5321, 4.5.3.1.1.
+internal const val MAXIMUM_LOCAL_PART_LENGTH = 64
+
+/**
+ * Represents an email address.
+ *
+ * This class currently doesn't support internationalized domain names (RFC 5891) or non-ASCII local parts (RFC 6532).
+ */
+class EmailAddress internal constructor(
+    val localPart: String,
+    val domain: EmailDomain,
+) {
+    val encodedLocalPart: String = if (localPart.isDotString) localPart else quoteString(localPart)
+
+    val warnings: Set<Warning>
+
     init {
-        require(address.isNotBlank()) { "Email address must not be blank" }
+        warnings = buildSet {
+            if (localPart.length > MAXIMUM_LOCAL_PART_LENGTH) {
+                add(Warning.LocalPartExceedsLengthLimit)
+            }
+
+            if (address.length > MAXIMUM_EMAIL_ADDRESS_LENGTH) {
+                add(Warning.EmailAddressExceedsLengthLimit)
+            }
+
+            if (localPart.isEmpty()) {
+                add(Warning.EmptyLocalPart)
+            }
+
+            if (!localPart.isDotString) {
+                add(Warning.QuotedStringInLocalPart)
+            }
+        }
+    }
+
+    val address: String
+        get() = "$encodedLocalPart@$domain"
+
+    val normalizedAddress: String
+        get() = "$encodedLocalPart@${domain.normalized}"
+
+    override fun toString(): String {
+        return address
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other == null || this::class != other::class) return false
+
+        other as EmailAddress
+
+        if (localPart != other.localPart) return false
+        return domain == other.domain
+    }
+
+    override fun hashCode(): Int {
+        var result = localPart.hashCode()
+        result = 31 * result + domain.hashCode()
+        return result
+    }
+
+    private fun quoteString(input: String): String {
+        return buildString {
+            append(DQUOTE)
+            for (character in input) {
+                if (!character.isQtext) {
+                    append(BACKSLASH)
+                }
+                append(character)
+            }
+            append(DQUOTE)
+        }
+    }
+
+    enum class Warning {
+        /**
+         * The local part exceeds the length limit (see RFC 5321, 4.5.3.1.1.).
+         */
+        LocalPartExceedsLengthLimit,
+
+        /**
+         * The email address exceeds the length limit (see RFC 5321, 4.5.3.1.3.; The maximum length of 'Path'
+         * indirectly limits the length of 'Mailbox').
+         */
+        EmailAddressExceedsLengthLimit,
+
+        /**
+         * The local part requires using a quoted string.
+         *
+         * This is valid, but very uncommon. Using such a local part should be avoided whenever possible.
+         */
+        QuotedStringInLocalPart,
+
+        /**
+         * The local part is the empty string.
+         *
+         * Even if you want to allow quoted strings, you probably don't want to allow this.
+         */
+        EmptyLocalPart,
+    }
+
+    companion object {
+        fun parse(address: String, config: EmailAddressParserConfig = EmailAddressParserConfig.RELAXED): EmailAddress {
+            return EmailAddressParser(address, config).parse()
+        }
     }
 }
+
+/**
+ * Converts this string to an [EmailAddress] instance using [EmailAddressParserConfig.RELAXED].
+ */
+fun String.toEmailAddressOrThrow() = EmailAddress.parse(this, EmailAddressParserConfig.RELAXED)
+
+/**
+ * Converts this string to an [EmailAddress] instance using [EmailAddressParserConfig.RELAXED].
+ */
+@Suppress("SwallowedException")
+fun String.toEmailAddressOrNull(): EmailAddress? {
+    return try {
+        EmailAddress.parse(this, EmailAddressParserConfig.RELAXED)
+    } catch (e: EmailAddressParserException) {
+        null
+    }
+}
+
+/**
+ * Convert this string into an [EmailAddress] instance using [EmailAddressParserConfig.LIMITED].
+ *
+ * Use this when validating the email address a user wants to add to an account/identity.
+ */
+fun String.toUserEmailAddress() = EmailAddress.parse(this, EmailAddressParserConfig.LIMITED)
diff --git a/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailAddressParser.kt b/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailAddressParser.kt
new file mode 100644
index 0000000000000000000000000000000000000000..fd03a6e725a7df6ac5d55677a239c27e749ed1de
--- /dev/null
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailAddressParser.kt
@@ -0,0 +1,164 @@
+package app.k9mail.core.common.mail
+
+import app.k9mail.core.common.mail.EmailAddress.Warning
+import app.k9mail.core.common.mail.EmailAddressParserError.AddressLiteralsNotSupported
+import app.k9mail.core.common.mail.EmailAddressParserError.EmptyLocalPart
+import app.k9mail.core.common.mail.EmailAddressParserError.ExpectedEndOfInput
+import app.k9mail.core.common.mail.EmailAddressParserError.InvalidDomainPart
+import app.k9mail.core.common.mail.EmailAddressParserError.InvalidDotString
+import app.k9mail.core.common.mail.EmailAddressParserError.InvalidLocalPart
+import app.k9mail.core.common.mail.EmailAddressParserError.InvalidQuotedString
+import app.k9mail.core.common.mail.EmailAddressParserError.LocalPartLengthExceeded
+import app.k9mail.core.common.mail.EmailAddressParserError.LocalPartRequiresQuotedString
+import app.k9mail.core.common.mail.EmailAddressParserError.QuotedStringInLocalPart
+import app.k9mail.core.common.mail.EmailAddressParserError.TotalLengthExceeded
+
+/**
+ * Parse an email address.
+ *
+ * This class currently doesn't support internationalized domain names (RFC 5891) or non-ASCII local parts (RFC 6532).
+ *
+ * From RFC 5321:
+ * ```
+ * Mailbox                 = Local-part "@" ( Domain / address-literal )
+ *
+ * Local-part              = Dot-string / Quoted-string
+ * Dot-string              = Atom *("."  Atom)
+ * Quoted-string           = DQUOTE *QcontentSMTP DQUOTE
+ * QcontentSMTP            = qtextSMTP / quoted-pairSMTP
+ * qtextSMTP               = %d32-33 / %d35-91 / %d93-126
+ * quoted-pairSMTP         = %d92 %d32-126
+ *
+ * Domain                  - see DomainParser
+ * address-literal         - We intentionally don't support address literals
+ * ```
+ */
+internal class EmailAddressParser(
+    input: String,
+    private val config: EmailAddressParserConfig,
+) : AbstractParser(input) {
+
+    fun parse(): EmailAddress {
+        val emailAddress = readEmailAddress()
+
+        if (!endReached()) {
+            parserError(ExpectedEndOfInput)
+        }
+
+        if (
+            config.isEmailAddressLengthCheckEnabled && Warning.EmailAddressExceedsLengthLimit in emailAddress.warnings
+        ) {
+            parserError(TotalLengthExceeded)
+        }
+
+        if (config.isLocalPartLengthCheckEnabled && Warning.LocalPartExceedsLengthLimit in emailAddress.warnings) {
+            parserError(LocalPartLengthExceeded, position = input.lastIndexOf('@'))
+        }
+
+        if (
+            !config.isLocalPartRequiringQuotedStringAllowed && Warning.QuotedStringInLocalPart in emailAddress.warnings
+        ) {
+            parserError(LocalPartRequiresQuotedString, position = 0)
+        }
+
+        if (!config.isEmptyLocalPartAllowed && Warning.EmptyLocalPart in emailAddress.warnings) {
+            parserError(EmptyLocalPart, position = 1)
+        }
+
+        return emailAddress
+    }
+
+    private fun readEmailAddress(): EmailAddress {
+        val localPart = readLocalPart()
+
+        expect(AT)
+        val domain = readDomainPart()
+
+        return EmailAddress(localPart, domain)
+    }
+
+    private fun readLocalPart(): String {
+        val character = peek()
+        val localPart = when {
+            character.isAtext -> {
+                readDotString()
+            }
+            character == DQUOTE -> {
+                if (config.isQuotedLocalPartAllowed) {
+                    readQuotedString()
+                } else {
+                    parserError(QuotedStringInLocalPart)
+                }
+            }
+            else -> {
+                parserError(InvalidLocalPart)
+            }
+        }
+
+        return localPart
+    }
+
+    private fun readDotString(): String {
+        return buildString {
+            appendAtom()
+
+            while (!endReached() && peek() == DOT) {
+                expect(DOT)
+                append(DOT)
+                appendAtom()
+            }
+        }
+    }
+
+    private fun StringBuilder.appendAtom() {
+        val startIndex = currentIndex
+        skipWhile { it.isAtext }
+
+        if (startIndex == currentIndex) {
+            parserError(InvalidDotString)
+        }
+
+        append(input, startIndex, currentIndex)
+    }
+
+    private fun readQuotedString(): String {
+        return buildString {
+            expect(DQUOTE)
+
+            while (!endReached()) {
+                val character = peek()
+                when {
+                    character.isQtext -> append(read())
+                    character == BACKSLASH -> {
+                        expect(BACKSLASH)
+                        val escapedCharacter = read()
+                        if (!escapedCharacter.isQuotedChar) {
+                            parserError(InvalidQuotedString)
+                        }
+                        append(escapedCharacter)
+                    }
+
+                    character == DQUOTE -> break
+                    else -> parserError(InvalidQuotedString)
+                }
+            }
+
+            expect(DQUOTE)
+        }
+    }
+
+    private fun readDomainPart(): EmailDomain {
+        val character = peek()
+        return when {
+            character.isLetDig -> readDomain()
+            character == '[' -> parserError(AddressLiteralsNotSupported)
+            else -> parserError(InvalidDomainPart)
+        }
+    }
+
+    private fun readDomain(): EmailDomain {
+        return withParser(EmailDomainParser(input, currentIndex)) {
+            readDomain()
+        }
+    }
+}
diff --git a/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailAddressParserConfig.kt b/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailAddressParserConfig.kt
new file mode 100644
index 0000000000000000000000000000000000000000..325b97975ce4a524a0f80d783b20788257d473a8
--- /dev/null
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailAddressParserConfig.kt
@@ -0,0 +1,65 @@
+package app.k9mail.core.common.mail
+
+/**
+ * Configuration to control the behavior when parsing an email address into [EmailAddress].
+ *
+ * @param isLocalPartLengthCheckEnabled When this is `true` the length of the local part is checked to make sure it
+ * doesn't exceed the specified limit (see RFC 5321, 4.5.3.1.1.).
+ *
+ * @param isEmailAddressLengthCheckEnabled When this is `true` the length of the whole email address is checked to make
+ * sure it doesn't exceed the specified limit (see RFC 5321, 4.5.3.1.3.; The maximum length of 'Path' indirectly limits
+ * the length of 'Mailbox').
+ *
+ * @param isQuotedLocalPartAllowed When this is `true`, the parsing step allows email addresses with a local part
+ * encoded as quoted string, e.g. `"foo bar"@domain.example`. Otherwise, the parser will throw an
+ * [EmailAddressParserException] as soon as a quoted string is encountered.
+ * Quoted strings in local parts are not widely used. It's recommended to disallow them whenever possible.
+ *
+ * @param isLocalPartRequiringQuotedStringAllowed Email addresses whose local part requires the use of a quoted string
+ * are only allowed when this is `true`. This is separate from [isQuotedLocalPartAllowed] because one might want to
+ * allow email addresses that unnecessarily use a quoted string, e.g. `"test"@domain.example`
+ * ([isQuotedLocalPartAllowed] = `true`, [isLocalPartRequiringQuotedStringAllowed] = `false`; [EmailAddress] will not
+ * retain the original form and treat this address exactly like `test@domain.example`). When allowing this, remember to
+ * use the value of [EmailAddress.address] instead of retaining the original user input.
+ *
+ * The value of this property is ignored if [isQuotedLocalPartAllowed] is `false`.
+ *
+ * @param isEmptyLocalPartAllowed Email addresses with an empty local part (e.g. `""@domain.example`) are only allowed
+ * if this value is `true`.
+ *
+ * The value of this property is ignored if at least one of [isQuotedLocalPartAllowed] and
+ * [isLocalPartRequiringQuotedStringAllowed] is `false`.
+ */
+data class EmailAddressParserConfig(
+    val isLocalPartLengthCheckEnabled: Boolean,
+    val isEmailAddressLengthCheckEnabled: Boolean,
+    val isQuotedLocalPartAllowed: Boolean,
+    val isLocalPartRequiringQuotedStringAllowed: Boolean,
+    val isEmptyLocalPartAllowed: Boolean = false,
+) {
+    companion object {
+        /**
+         * This allows local parts requiring quoted strings and disables length checks for the local part and the
+         * whole email address.
+         */
+        val RELAXED = EmailAddressParserConfig(
+            isLocalPartLengthCheckEnabled = false,
+            isEmailAddressLengthCheckEnabled = false,
+            isQuotedLocalPartAllowed = true,
+            isLocalPartRequiringQuotedStringAllowed = true,
+            isEmptyLocalPartAllowed = false,
+        )
+
+        /**
+         * This only allows a subset of valid email addresses. Use this when validating the email address a user wants
+         * to add to an account/identity.
+         */
+        val LIMITED = EmailAddressParserConfig(
+            isLocalPartLengthCheckEnabled = true,
+            isEmailAddressLengthCheckEnabled = true,
+            isQuotedLocalPartAllowed = false,
+            isLocalPartRequiringQuotedStringAllowed = false,
+            isEmptyLocalPartAllowed = false,
+        )
+    }
+}
diff --git a/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailAddressParserError.kt b/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailAddressParserError.kt
new file mode 100644
index 0000000000000000000000000000000000000000..61933cff0fdae1e8e86bf14c306c4fa88b543333
--- /dev/null
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailAddressParserError.kt
@@ -0,0 +1,22 @@
+package app.k9mail.core.common.mail
+
+enum class EmailAddressParserError(internal val message: String) {
+    UnexpectedEndOfInput("End of input reached unexpectedly"),
+    ExpectedEndOfInput("Expected end of input"),
+    InvalidLocalPart("Expected 'Dot-string' or 'Quoted-string'"),
+    InvalidDotString("Expected 'Dot-string'"),
+    InvalidQuotedString("Expected 'Quoted-string'"),
+    InvalidDomainPart("Expected 'Domain' or 'address-literal'"),
+    AddressLiteralsNotSupported("Address literals are not supported"),
+
+    LocalPartLengthExceeded("Local part exceeds maximum length of $MAXIMUM_LOCAL_PART_LENGTH characters"),
+    DnsLabelLengthExceeded("DNS labels exceeds maximum length of $MAXIMUM_DNS_LABEL_LENGTH characters"),
+    DomainLengthExceeded("Domain exceeds maximum length of $MAXIMUM_DOMAIN_LENGTH characters"),
+    TotalLengthExceeded("The email address exceeds the maximum length of $MAXIMUM_EMAIL_ADDRESS_LENGTH characters"),
+
+    QuotedStringInLocalPart("Quoted string in local part is not allowed by config"),
+    LocalPartRequiresQuotedString("Local part requiring the use of a quoted string is not allowed by config"),
+    EmptyLocalPart("Empty local part is not allowed by config"),
+
+    UnexpectedCharacter("Caller needs to provide message"),
+}
diff --git a/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailAddressParserException.kt b/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailAddressParserException.kt
new file mode 100644
index 0000000000000000000000000000000000000000..074b87c98594649913802033c5793b533f1aeaca
--- /dev/null
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailAddressParserException.kt
@@ -0,0 +1,8 @@
+package app.k9mail.core.common.mail
+
+class EmailAddressParserException internal constructor(
+    message: String,
+    val error: EmailAddressParserError,
+    val input: String,
+    val position: Int,
+) : RuntimeException(message)
diff --git a/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailDomain.kt b/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailDomain.kt
new file mode 100644
index 0000000000000000000000000000000000000000..9c8800821e25f1ec46604613576461375f642631
--- /dev/null
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailDomain.kt
@@ -0,0 +1,51 @@
+package app.k9mail.core.common.mail
+
+import app.k9mail.core.common.net.Domain
+
+/**
+ * The domain part of an email address.
+ *
+ * @param value String representation of the email domain with the original capitalization.
+ */
+class EmailDomain internal constructor(val value: String) {
+    /**
+     * The normalized (converted to lower case) string representation of this email domain.
+     */
+    val normalized: String = value.lowercase()
+
+    /**
+     * Returns this email domain with the original capitalization.
+     *
+     * @see value
+     */
+    override fun toString(): String = value
+
+    /**
+     * Compares the normalized string representations of two [EmailDomain] instances.
+     */
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other == null || this::class != other::class) return false
+
+        other as EmailDomain
+
+        return normalized == other.normalized
+    }
+
+    override fun hashCode(): Int {
+        return normalized.hashCode()
+    }
+
+    companion object {
+        /**
+         * Parses the string representation of an email domain.
+         *
+         * @throws EmailAddressParserException in case of an error.
+         */
+        fun parse(domain: String): EmailDomain {
+            return EmailDomainParser(domain).parseDomain()
+        }
+    }
+}
+
+fun EmailDomain.toDomain() = Domain(value)
diff --git a/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailDomainParser.kt b/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailDomainParser.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d7a9badf424bf6b6573a17cf7fadac098bf7ac33
--- /dev/null
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/mail/EmailDomainParser.kt
@@ -0,0 +1,92 @@
+package app.k9mail.core.common.mail
+
+import app.k9mail.core.common.mail.EmailAddressParserError.DnsLabelLengthExceeded
+import app.k9mail.core.common.mail.EmailAddressParserError.DomainLengthExceeded
+import app.k9mail.core.common.mail.EmailAddressParserError.ExpectedEndOfInput
+
+// See RFC 1035, 2.3.4.
+// For the string representation used in emails (labels separated by dots, no final dot allowed), we end up with a
+// maximum of 253 characters.
+internal const val MAXIMUM_DOMAIN_LENGTH = 253
+
+// See RFC 1035, 2.3.4.
+internal const val MAXIMUM_DNS_LABEL_LENGTH = 63
+
+/**
+ * Parser for domain names in email addresses.
+ *
+ * From RFC 5321:
+ * ```
+ * Domain                  = sub-domain *("." sub-domain)
+ * sub-domain              = Let-dig [Ldh-str]
+ * Let-dig                 = ALPHA / DIGIT
+ * Ldh-str                 = *( ALPHA / DIGIT / "-" ) Let-dig
+ * ```
+ */
+internal class EmailDomainParser(
+    input: String,
+    startIndex: Int = 0,
+    endIndex: Int = input.length,
+) : AbstractParser(input, startIndex, endIndex) {
+
+    fun parseDomain(): EmailDomain {
+        val domain = readDomain()
+
+        if (!endReached()) {
+            parserError(ExpectedEndOfInput)
+        }
+
+        return domain
+    }
+
+    fun readDomain(): EmailDomain {
+        val domain = readString {
+            expectSubDomain()
+
+            while (!endReached() && peek() == DOT) {
+                expect(DOT)
+                expectSubDomain()
+            }
+        }
+
+        if (domain.length > MAXIMUM_DOMAIN_LENGTH) {
+            parserError(DomainLengthExceeded)
+        }
+
+        return EmailDomain(domain)
+    }
+
+    private fun expectSubDomain() {
+        val startIndex = currentIndex
+
+        expectLetDig()
+
+        var requireLetDig = false
+        while (!endReached()) {
+            val character = peek()
+            when {
+                character == HYPHEN -> {
+                    requireLetDig = true
+                    expect(HYPHEN)
+                }
+                character.isLetDig -> {
+                    requireLetDig = false
+                    expectLetDig()
+                }
+                else -> break
+            }
+        }
+
+        if (requireLetDig) {
+            expectLetDig()
+        }
+
+        if (currentIndex - startIndex > MAXIMUM_DNS_LABEL_LENGTH) {
+            parserError(DnsLabelLengthExceeded)
+        }
+    }
+
+    private fun expectLetDig() {
+        expect("'Let-dig'") { it.isLetDig }
+    }
+}
diff --git a/app/core/src/main/java/com/fsck/k9/preferences/Protocols.kt b/core/common/src/main/kotlin/app/k9mail/core/common/mail/Protocols.kt
similarity index 74%
rename from app/core/src/main/java/com/fsck/k9/preferences/Protocols.kt
rename to core/common/src/main/kotlin/app/k9mail/core/common/mail/Protocols.kt
index 51f20970f3bf78f1c710b2b7b88f29b46c17b2a3..325609f1f2c000a24a484137d7f8afde2637f514 100644
--- a/app/core/src/main/java/com/fsck/k9/preferences/Protocols.kt
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/mail/Protocols.kt
@@ -1,4 +1,4 @@
-package com.fsck.k9.preferences
+package app.k9mail.core.common.mail
 
 object Protocols {
     const val IMAP = "imap"
diff --git a/core/common/src/main/kotlin/app/k9mail/core/common/mail/Tokens.kt b/core/common/src/main/kotlin/app/k9mail/core/common/mail/Tokens.kt
new file mode 100644
index 0000000000000000000000000000000000000000..079556642766cbd31a85aa97d477c17ba965e0d3
--- /dev/null
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/mail/Tokens.kt
@@ -0,0 +1,66 @@
+@file:Suppress("MagicNumber")
+
+package app.k9mail.core.common.mail
+
+internal const val DQUOTE = '"'
+internal const val DOT = '.'
+internal const val AT = '@'
+internal const val BACKSLASH = '\\'
+internal const val HYPHEN = '-'
+
+internal val ATEXT_EXTRA = charArrayOf(
+    '!', '#', '$', '%', '&', '\'', '*', '+', '-', '/', '=', '?', '^', '_', '`', '{', '|', '}', '~',
+)
+
+// RFC 5234: ALPHA = %x41-5A / %x61-7A    ; A-Z / a-z
+internal val Char.isALPHA
+    get() = this in 'A'..'Z' || this in 'a'..'z'
+
+// RFC 5234: DIGIT = %x30-39    ; 0-9
+internal val Char.isDIGIT
+    get() = this in '0'..'9'
+
+// RFC 5322:
+// atext = ALPHA / DIGIT /    ; Printable US-ASCII
+//         "!" / "#" /        ;  characters not including
+//         "$" / "%" /        ;  specials.  Used for atoms.
+//         "&" / "'" /
+//         "*" / "+" /
+//         "-" / "/" /
+//         "=" / "?" /
+//         "^" / "_" /
+//         "`" / "{" /
+//         "|" / "}" /
+//         "~"
+internal val Char.isAtext
+    get() = isALPHA || isDIGIT || this in ATEXT_EXTRA
+
+// RFC 5321: qtextSMTP = %d32-33 / %d35-91 / %d93-126
+internal val Char.isQtext
+    get() = code.let { it in 32..33 || it in 35..91 || it in 93..126 }
+
+// RFC 5321: second character of quoted-pairSMTP = %d92 %d32-126
+internal val Char.isQuotedChar
+    get() = code in 32..126
+
+// RFC 5321:
+// Dot-string = Atom *("."  Atom)
+// Atom       = 1*atext
+internal val String.isDotString: Boolean
+    get() {
+        if (isEmpty() || this[0] == DOT || this[lastIndex] == DOT) return false
+        for (i in 0..lastIndex) {
+            val character = this[i]
+            when {
+                character == DOT -> if (this[i - 1] == DOT) return false
+                character.isAtext -> Unit
+                else -> return false
+            }
+        }
+
+        return true
+    }
+
+// RFC 5321: Let-dig = ALPHA / DIGIT
+internal val Char.isLetDig
+    get() = isALPHA || isDIGIT
diff --git a/core/common/src/main/kotlin/app/k9mail/core/common/net/Domain.kt b/core/common/src/main/kotlin/app/k9mail/core/common/net/Domain.kt
new file mode 100644
index 0000000000000000000000000000000000000000..4c5216134c7edabc8bee38d7130a7d143656c0f2
--- /dev/null
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/net/Domain.kt
@@ -0,0 +1,10 @@
+package app.k9mail.core.common.net
+
+@JvmInline
+value class Domain(val value: String) {
+    init {
+        requireNotNull(HostNameUtils.isLegalHostName(value)) { "Not a valid domain name: '$value'" }
+    }
+}
+
+fun String.toDomain() = Domain(this)
diff --git a/core/common/src/main/kotlin/app/k9mail/core/common/net/HostNameUtils.kt b/core/common/src/main/kotlin/app/k9mail/core/common/net/HostNameUtils.kt
new file mode 100644
index 0000000000000000000000000000000000000000..91e1f2ba3ac67a38af6d3fa47777e8d049167cfb
--- /dev/null
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/net/HostNameUtils.kt
@@ -0,0 +1,225 @@
+package app.k9mail.core.common.net
+
+/**
+ * Code to check the validity of host names and IP addresses.
+ *
+ * Based on
+ * [mailnews/base/src/hostnameUtils.jsm](https://searchfox.org/comm-central/source/mailnews/base/src/hostnameUtils.jsm)
+ *
+ * Note: The naming of these functions is inconsistent with the rest of the Android project to match the original
+ * source. Please use more appropriate names when refactoring this code.
+ */
+@Suppress("MagicNumber", "ReturnCount")
+object HostNameUtils {
+    /**
+     * Check if `hostName` is an IP address or a valid hostname.
+     *
+     * @return Unobscured host name if `hostName` is valid.
+     */
+    fun isLegalHostNameOrIP(hostName: String): String? {
+        /*
+         RFC 1123:
+         Whenever a user inputs the identity of an Internet host, it SHOULD
+         be possible to enter either (1) a host domain name or (2) an IP
+         address in dotted-decimal ("#.#.#.#") form.  The host SHOULD check
+         the string syntactically for a dotted-decimal number before
+         looking it up in the Domain Name System.
+        */
+
+        return isLegalIPAddress(hostName) ?: isLegalHostName(hostName)
+    }
+
+    /**
+     * Check if `hostName` is a valid IP address (IPv4 or IPv6).
+     *
+     * @return Unobscured canonicalized IPv4 or IPv6 address if it is valid, otherwise `null`.
+     */
+    fun isLegalIPAddress(hostName: String): String? {
+        return isLegalIPv4Address(hostName) ?: isLegalIPv6Address(hostName)
+    }
+
+    /**
+     * Check if `hostName` is a valid IPv4 address.
+     *
+     * @return Unobscured canonicalized address if `hostName` is an IPv4 address. Returns `null` if it's not.
+     */
+    fun isLegalIPv4Address(hostName: String): String? {
+        // Break the IP address down into individual components.
+        val ipComponentStrings = hostName.split(".")
+        if (ipComponentStrings.size != 4) {
+            return null
+        }
+
+        val ipComponents = ipComponentStrings.map { toIPv4NumericComponent(it) }
+
+        if (ipComponents.any { it == null }) {
+            return null
+        }
+
+        // First component of zero is not valid.
+        if (ipComponents.first() == 0) {
+            return null
+        }
+
+        return hostName
+    }
+
+    /**
+     * Converts an IPv4 address component to a number if it is valid. Returns `null` otherwise.
+     */
+    private fun toIPv4NumericComponent(value: String): Int? {
+        return if (IPV4_COMPONENT_PATTERN.matches(value)) {
+            value.toInt(radix = 10).takeIf { it in 0..255 }
+        } else {
+            null
+        }
+    }
+
+    /**
+     * Check if `hostName` is a valid IPv6 address.
+     *
+     * @returns Unobscured canonicalized address if `hostName` is an IPv6 address. Returns `null` if it's not.
+     */
+    fun isLegalIPv6Address(hostName: String): String? {
+        // Break the IP address down into individual components.
+        val ipComponentStrings = hostName.lowercase().split(":")
+
+        // Make sure there are at least 3 components.
+        if (ipComponentStrings.size < 3) {
+            return null
+        }
+
+        // Take care if the last part is written in decimal using dots as separators.
+        val lastPart = isLegalIPv4Address(ipComponentStrings.last())
+        val ipComponentHexStrings = if (lastPart != null) {
+            val lastPartComponents = lastPart.split(".").map { it.toInt(radix = 10) }
+            // Convert it into standard IPv6 components.
+            val part1 = ((lastPartComponents[0] shl 8) or lastPartComponents[1]).toString(radix = 16)
+            val part2 = ((lastPartComponents[2] shl 8) or lastPartComponents[3]).toString(radix = 16)
+
+            ipComponentStrings.subList(0, ipComponentStrings.lastIndex) + part1 + part2
+        } else {
+            ipComponentStrings
+        }
+
+        // Make sure that there is only one empty component.
+        var emptyIndex = -1
+        for (index in 1 until ipComponentHexStrings.lastIndex) {
+            if (ipComponentHexStrings[index] == "") {
+                // If we already found an empty component return null.
+                if (emptyIndex != -1) {
+                    return null
+                }
+
+                emptyIndex = index
+            }
+        }
+
+        // If we found an empty component, extend it.
+        val fullIpComponentStrings = if (emptyIndex != -1) {
+            buildList(capacity = 8) {
+                for (i in 0 until emptyIndex) {
+                    add(ipComponentHexStrings[i])
+                }
+
+                repeat(8 - ipComponentHexStrings.size + 1) {
+                    add("0")
+                }
+
+                for (i in (emptyIndex + 1)..ipComponentHexStrings.lastIndex) {
+                    add(ipComponentHexStrings[i])
+                }
+            }
+        } else {
+            ipComponentHexStrings
+        }
+
+        // Make sure there are 8 components.
+        if (fullIpComponentStrings.size != 8) {
+            return null
+        }
+
+        // Format all components to 4 character hex value.
+        val ipComponents = fullIpComponentStrings.map { ipComponentString ->
+            if (ipComponentString == "") {
+                0
+            } else if (IPV6_COMPONENT_PATTERN.matches(ipComponentString)) {
+                ipComponentString.toInt(radix = 16)
+            } else {
+                return null
+            }
+        }
+
+        // Treat 0000:0000:0000:0000:0000:0000:0000:0000 as an invalid IPv6 address.
+        if (ipComponents.all { it == 0 }) {
+            return null
+        }
+
+        // Pad the component with 0:s.
+        val canonicalIpComponents = ipComponents.map { it.toString(radix = 16).padStart(4, '0') }
+
+        // TODO: support Zone indices in Link-local addresses? Currently they are rejected.
+        // http://en.wikipedia.org/wiki/IPv6_address#Link-local_addresses_and_zone_indices
+
+        return canonicalIpComponents.joinToString(":")
+    }
+
+    /**
+     * Check if `hostName` is a valid hostname.
+     *
+     * @returns The host name if it is valid. Returns `null` if it's not.
+     */
+    fun isLegalHostName(hostName: String): String? {
+        /*
+         RFC 952:
+         A "name" (Net, Host, Gateway, or Domain name) is a text string up
+         to 24 characters drawn from the alphabet (A-Z), digits (0-9), minus
+         sign (-), and period (.).  Note that periods are only allowed when
+         they serve to delimit components of "domain style names". (See
+         RFC-921, "Domain Name System Implementation Schedule", for
+         background).  No blank or space characters are permitted as part of a
+         name. No distinction is made between upper and lower case.  The first
+         character must be an alpha character.  The last character must not be
+         a minus sign or period.
+
+         RFC 1123:
+         The syntax of a legal Internet host name was specified in RFC-952
+         [DNS:4].  One aspect of host name syntax is hereby changed: the
+         restriction on the first character is relaxed to allow either a
+         letter or a digit.  Host software MUST support this more liberal
+         syntax.
+
+         Host software MUST handle host names of up to 63 characters and
+         SHOULD handle host names of up to 255 characters.
+
+         RFC 1034:
+         Relative names are either taken relative to a well known origin, or to a
+         list of domains used as a search list.  Relative names appear mostly at
+         the user interface, where their interpretation varies from
+         implementation to implementation, and in master files, where they are
+         relative to a single origin domain name.  The most common interpretation
+         uses the root "." as either the single origin or as one of the members
+         of the search list, so a multi-label relative name is often one where
+         the trailing dot has been omitted to save typing.
+
+         Since a complete domain name ends with the root label, this leads to
+         a printed form which ends in a dot.
+        */
+
+        return hostName.takeIf { hostName.length <= 255 && HOST_PATTERN.matches(hostName) }
+    }
+
+    /**
+     * Clean up the hostname or IP. Usually used to sanitize a value input by the user.
+     * It is usually applied before we know if the hostname is even valid.
+     */
+    fun cleanUpHostName(hostName: String): String {
+        return hostName.trim()
+    }
+
+    private const val LDH_LABEL = "([a-z0-9]|[a-z0-9][a-z0-9\\-]{0,61}[a-z0-9])"
+    private val HOST_PATTERN = """($LDH_LABEL\.)*$LDH_LABEL\.?""".toRegex(RegexOption.IGNORE_CASE)
+
+    private val IPV4_COMPONENT_PATTERN = "(0|([1-9][0-9]{0,2}))".toRegex()
+    private val IPV6_COMPONENT_PATTERN = "[0-9a-f]{1,4}".toRegex()
+}
diff --git a/core/common/src/main/kotlin/app/k9mail/core/common/net/Hostname.kt b/core/common/src/main/kotlin/app/k9mail/core/common/net/Hostname.kt
new file mode 100644
index 0000000000000000000000000000000000000000..21286aca38fda90e4c610216e3a62636961d2a39
--- /dev/null
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/net/Hostname.kt
@@ -0,0 +1,15 @@
+package app.k9mail.core.common.net
+
+/**
+ * Represents a hostname, IPv4, or IPv6 address.
+ */
+@JvmInline
+value class Hostname(val value: String) {
+    init {
+        requireNotNull(HostNameUtils.isLegalHostNameOrIP(value)) { "Not a valid domain or IP: '$value'" }
+    }
+}
+
+fun String.toHostname() = Hostname(this)
+
+fun Hostname.isIpAddress(): Boolean = HostNameUtils.isLegalIPAddress(value) != null
diff --git a/core/common/src/main/kotlin/app/k9mail/core/common/net/Port.kt b/core/common/src/main/kotlin/app/k9mail/core/common/net/Port.kt
new file mode 100644
index 0000000000000000000000000000000000000000..73d0232730041b5cc910d954da29ce4c4f35a2df
--- /dev/null
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/net/Port.kt
@@ -0,0 +1,11 @@
+package app.k9mail.core.common.net
+
+@Suppress("MagicNumber")
+@JvmInline
+value class Port(val value: Int) {
+    init {
+        require(value in 1..65535) { "Not a valid port number: $value" }
+    }
+}
+
+fun Int.toPort() = Port(this)
diff --git a/core/common/src/main/kotlin/app/k9mail/core/common/oauth/InMemoryOAuthConfigurationProvider.kt b/core/common/src/main/kotlin/app/k9mail/core/common/oauth/InMemoryOAuthConfigurationProvider.kt
new file mode 100644
index 0000000000000000000000000000000000000000..2ad54fb4736497ba3c62e8224c59f361b2b41f1a
--- /dev/null
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/oauth/InMemoryOAuthConfigurationProvider.kt
@@ -0,0 +1,18 @@
+package app.k9mail.core.common.oauth
+
+internal class InMemoryOAuthConfigurationProvider(
+    private val configurationFactory: OAuthConfigurationFactory,
+) : OAuthConfigurationProvider {
+
+    private val hostnameMapping: Map<String, OAuthConfiguration> = buildMap {
+        for ((hostnames, configuration) in configurationFactory.createConfigurations()) {
+            for (hostname in hostnames) {
+                put(hostname.lowercase(), configuration)
+            }
+        }
+    }
+
+    override fun getConfiguration(hostname: String): OAuthConfiguration? {
+        return hostnameMapping[hostname.lowercase()]
+    }
+}
diff --git a/app/core/src/main/java/com/fsck/k9/oauth/OAuthConfiguration.kt b/core/common/src/main/kotlin/app/k9mail/core/common/oauth/OAuthConfiguration.kt
similarity index 83%
rename from app/core/src/main/java/com/fsck/k9/oauth/OAuthConfiguration.kt
rename to core/common/src/main/kotlin/app/k9mail/core/common/oauth/OAuthConfiguration.kt
index dd43a605738e71e7ed861b49002c9120c455805f..971a792a682ff760134701d61a2f2882e478965e 100644
--- a/app/core/src/main/java/com/fsck/k9/oauth/OAuthConfiguration.kt
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/oauth/OAuthConfiguration.kt
@@ -1,4 +1,4 @@
-package com.fsck.k9.oauth
+package app.k9mail.core.common.oauth
 
 data class OAuthConfiguration(
     val clientId: String,
diff --git a/core/common/src/main/kotlin/app/k9mail/core/common/oauth/OAuthConfigurationFactory.kt b/core/common/src/main/kotlin/app/k9mail/core/common/oauth/OAuthConfigurationFactory.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d7279c5f47235f0dd120e9830ca4eddde943b6be
--- /dev/null
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/oauth/OAuthConfigurationFactory.kt
@@ -0,0 +1,5 @@
+package app.k9mail.core.common.oauth
+
+fun interface OAuthConfigurationFactory {
+    fun createConfigurations(): Map<List<String>, OAuthConfiguration>
+}
diff --git a/core/common/src/main/kotlin/app/k9mail/core/common/oauth/OAuthConfigurationProvider.kt b/core/common/src/main/kotlin/app/k9mail/core/common/oauth/OAuthConfigurationProvider.kt
new file mode 100644
index 0000000000000000000000000000000000000000..ad29f86cdaeda6e698e601c40b726cea58cc44ad
--- /dev/null
+++ b/core/common/src/main/kotlin/app/k9mail/core/common/oauth/OAuthConfigurationProvider.kt
@@ -0,0 +1,5 @@
+package app.k9mail.core.common.oauth
+
+fun interface OAuthConfigurationProvider {
+    fun getConfiguration(hostname: String): OAuthConfiguration?
+}
diff --git a/core/common/src/test/kotlin/app/k9mail/core/common/CoreCommonModuleKtTest.kt b/core/common/src/test/kotlin/app/k9mail/core/common/CoreCommonModuleKtTest.kt
index 9ecbbe6aae49116a41a84b9650c0a4e6482c3cbb..79084e6fda44d5cd3b337c8398941cd341253823 100644
--- a/core/common/src/test/kotlin/app/k9mail/core/common/CoreCommonModuleKtTest.kt
+++ b/core/common/src/test/kotlin/app/k9mail/core/common/CoreCommonModuleKtTest.kt
@@ -1,15 +1,32 @@
 package app.k9mail.core.common
 
+import app.k9mail.core.common.oauth.OAuthConfigurationFactory
 import org.junit.Test
+import org.koin.core.annotation.KoinExperimentalAPI
 import org.koin.dsl.koinApplication
+import org.koin.dsl.module
 import org.koin.test.check.checkModules
+import org.koin.test.verify.verify
 
+@OptIn(KoinExperimentalAPI::class)
 internal class CoreCommonModuleKtTest {
 
+    private val externalModule = module {
+        single<OAuthConfigurationFactory> {
+            OAuthConfigurationFactory { emptyMap() }
+        }
+    }
+
     @Test
     fun `should have a valid di module`() {
+        coreCommonModule.verify(
+            extraTypes = listOf(
+                OAuthConfigurationFactory::class,
+            ),
+        )
+
         koinApplication {
-            modules(coreCommonModule)
+            modules(externalModule, coreCommonModule)
             checkModules()
         }
     }
diff --git a/core/common/src/test/kotlin/app/k9mail/core/common/mail/EmailAddressParserTest.kt b/core/common/src/test/kotlin/app/k9mail/core/common/mail/EmailAddressParserTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..48431066a4dcc3d30bbda9ab8a7617ec97bbd074
--- /dev/null
+++ b/core/common/src/test/kotlin/app/k9mail/core/common/mail/EmailAddressParserTest.kt
@@ -0,0 +1,321 @@
+package app.k9mail.core.common.mail
+
+import app.k9mail.core.common.mail.EmailAddressParserError.AddressLiteralsNotSupported
+import app.k9mail.core.common.mail.EmailAddressParserError.EmptyLocalPart
+import app.k9mail.core.common.mail.EmailAddressParserError.ExpectedEndOfInput
+import app.k9mail.core.common.mail.EmailAddressParserError.InvalidDomainPart
+import app.k9mail.core.common.mail.EmailAddressParserError.InvalidDotString
+import app.k9mail.core.common.mail.EmailAddressParserError.InvalidLocalPart
+import app.k9mail.core.common.mail.EmailAddressParserError.InvalidQuotedString
+import app.k9mail.core.common.mail.EmailAddressParserError.LocalPartLengthExceeded
+import app.k9mail.core.common.mail.EmailAddressParserError.LocalPartRequiresQuotedString
+import app.k9mail.core.common.mail.EmailAddressParserError.QuotedStringInLocalPart
+import app.k9mail.core.common.mail.EmailAddressParserError.TotalLengthExceeded
+import app.k9mail.core.common.mail.EmailAddressParserError.UnexpectedCharacter
+import assertk.all
+import assertk.assertFailure
+import assertk.assertThat
+import assertk.assertions.contains
+import assertk.assertions.hasMessage
+import assertk.assertions.isEqualTo
+import assertk.assertions.isInstanceOf
+import assertk.assertions.prop
+import kotlin.test.Test
+
+class EmailAddressParserTest {
+    @Test
+    fun `simple address`() {
+        val emailAddress = parseEmailAddress("alice@domain.example")
+
+        assertThat(emailAddress.localPart).isEqualTo("alice")
+        assertThat(emailAddress.domain).isEqualTo(EmailDomain("domain.example"))
+    }
+
+    @Test
+    fun `local part containing dot`() {
+        val emailAddress = parseEmailAddress("alice.lastname@domain.example")
+
+        assertThat(emailAddress.localPart).isEqualTo("alice.lastname")
+        assertThat(emailAddress.domain).isEqualTo(EmailDomain("domain.example"))
+    }
+
+    @Test
+    fun `quoted local part`() {
+        val emailAddress = parseEmailAddress(
+            address = "\"one two\"@domain.example",
+            isLocalPartRequiringQuotedStringAllowed = true,
+        )
+
+        assertThat(emailAddress.localPart).isEqualTo("one two")
+        assertThat(emailAddress.domain).isEqualTo(EmailDomain("domain.example"))
+    }
+
+    @Test
+    fun `quoted local part not allowed`() {
+        assertFailure {
+            parseEmailAddress(
+                address = "\"one two\"@domain.example",
+                isQuotedLocalPartAllowed = true,
+                isLocalPartRequiringQuotedStringAllowed = false,
+            )
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(LocalPartRequiresQuotedString)
+            prop(EmailAddressParserException::position).isEqualTo(0)
+            hasMessage("Local part requiring the use of a quoted string is not allowed by config")
+        }
+    }
+
+    @Test
+    fun `unnecessarily quoted local part`() {
+        val emailAddress = parseEmailAddress(
+            address = "\"user\"@domain.example",
+            isQuotedLocalPartAllowed = true,
+            isLocalPartRequiringQuotedStringAllowed = false,
+        )
+
+        assertThat(emailAddress.localPart).isEqualTo("user")
+        assertThat(emailAddress.domain).isEqualTo(EmailDomain("domain.example"))
+        assertThat(emailAddress.address).isEqualTo("user@domain.example")
+    }
+
+    @Test
+    fun `unnecessarily quoted local part not allowed`() {
+        assertFailure {
+            parseEmailAddress("\"user\"@domain.example", isQuotedLocalPartAllowed = false)
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(QuotedStringInLocalPart)
+            prop(EmailAddressParserException::position).isEqualTo(0)
+            hasMessage("Quoted string in local part is not allowed by config")
+        }
+    }
+
+    @Test
+    fun `quoted local part containing double quote character`() {
+        val emailAddress = parseEmailAddress(
+            address = """"a\"b"@domain.example""",
+            isLocalPartRequiringQuotedStringAllowed = true,
+        )
+
+        assertThat(emailAddress.localPart).isEqualTo("a\"b")
+        assertThat(emailAddress.domain).isEqualTo(EmailDomain("domain.example"))
+        assertThat(emailAddress.address).isEqualTo(""""a\"b"@domain.example""")
+    }
+
+    @Test
+    fun `empty local part`() {
+        val emailAddress = parseEmailAddress("\"\"@domain.example", isEmptyLocalPartAllowed = true)
+
+        assertThat(emailAddress.localPart).isEqualTo("")
+        assertThat(emailAddress.domain).isEqualTo(EmailDomain("domain.example"))
+        assertThat(emailAddress.address).isEqualTo("\"\"@domain.example")
+    }
+
+    @Test
+    fun `empty local part not allowed`() {
+        assertFailure {
+            parseEmailAddress(
+                address = "\"\"@domain.example",
+                isLocalPartRequiringQuotedStringAllowed = true,
+                isEmptyLocalPartAllowed = false,
+            )
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(EmptyLocalPart)
+            prop(EmailAddressParserException::position).isEqualTo(1)
+            hasMessage("Empty local part is not allowed by config")
+        }
+    }
+
+    @Test
+    fun `IPv4 address literal`() {
+        assertFailure {
+            parseEmailAddress("user@[255.0.100.23]")
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(AddressLiteralsNotSupported)
+            prop(EmailAddressParserException::position).isEqualTo(5)
+            hasMessage("Address literals are not supported")
+        }
+    }
+
+    @Test
+    fun `IPv6 address literal`() {
+        assertFailure {
+            parseEmailAddress("user@[IPv6:2001:0db8:0000:0000:0000:ff00:0042:8329]")
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(AddressLiteralsNotSupported)
+            prop(EmailAddressParserException::position).isEqualTo(5)
+            hasMessage("Address literals are not supported")
+        }
+    }
+
+    @Test
+    fun `domain part starts with unsupported value`() {
+        assertFailure {
+            parseEmailAddress("user@ä")
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(InvalidDomainPart)
+            prop(EmailAddressParserException::position).isEqualTo(5)
+            hasMessage("Expected 'Domain' or 'address-literal'")
+        }
+    }
+
+    @Test
+    fun `obsolete syntax`() {
+        assertFailure {
+            parseEmailAddress("\"quoted\".atom@domain.example", isLocalPartRequiringQuotedStringAllowed = true)
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(UnexpectedCharacter)
+            prop(EmailAddressParserException::position).isEqualTo(8)
+            hasMessage("Expected '@' (64)")
+        }
+    }
+
+    @Test
+    fun `local part starting with dot`() {
+        assertFailure {
+            parseEmailAddress(".invalid@domain.example")
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(InvalidLocalPart)
+            prop(EmailAddressParserException::position).isEqualTo(0)
+            hasMessage("Expected 'Dot-string' or 'Quoted-string'")
+        }
+    }
+
+    @Test
+    fun `local part ending with dot`() {
+        assertFailure {
+            parseEmailAddress("invalid.@domain.example")
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(InvalidDotString)
+            prop(EmailAddressParserException::position).isEqualTo(8)
+            hasMessage("Expected 'Dot-string'")
+        }
+    }
+
+    @Test
+    fun `quoted local part missing closing double quote`() {
+        assertFailure {
+            parseEmailAddress("\"invalid@domain.example", isLocalPartRequiringQuotedStringAllowed = true)
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(UnexpectedCharacter)
+            prop(EmailAddressParserException::position).isEqualTo(23)
+            hasMessage("Expected '\"' (34)")
+        }
+    }
+
+    @Test
+    fun `quoted text containing unsupported character`() {
+        assertFailure {
+            parseEmailAddress("\"ä\"@domain.example", isLocalPartRequiringQuotedStringAllowed = true)
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(InvalidQuotedString)
+            prop(EmailAddressParserException::position).isEqualTo(1)
+            hasMessage("Expected 'Quoted-string'")
+        }
+    }
+
+    @Test
+    fun `quoted text containing unsupported escaped character`() {
+        assertFailure {
+            parseEmailAddress(""""\ä"@domain.example""", isLocalPartRequiringQuotedStringAllowed = true)
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(InvalidQuotedString)
+            prop(EmailAddressParserException::position).isEqualTo(3)
+            hasMessage("Expected 'Quoted-string'")
+        }
+    }
+
+    @Test
+    fun `local part exceeds maximum size with length check enabled`() {
+        assertFailure {
+            parseEmailAddress(
+                address = "1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx12345@domain.example",
+                isLocalPartLengthCheckEnabled = true,
+            )
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(LocalPartLengthExceeded)
+            prop(EmailAddressParserException::position).isEqualTo(65)
+            hasMessage("Local part exceeds maximum length of 64 characters")
+        }
+    }
+
+    @Test
+    fun `local part exceeds maximum size with length check disabled`() {
+        val input = "1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx12345@domain.example"
+
+        val emailAddress = parseEmailAddress(address = input, isLocalPartLengthCheckEnabled = false)
+
+        assertThat(emailAddress.localPart)
+            .isEqualTo("1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx12345")
+        assertThat(emailAddress.domain).isEqualTo(EmailDomain("domain.example"))
+        assertThat(emailAddress.address).isEqualTo(input)
+        assertThat(emailAddress.warnings).contains(EmailAddress.Warning.LocalPartExceedsLengthLimit)
+    }
+
+    @Test
+    fun `email exceeds maximum size with length check enabled`() {
+        assertFailure {
+            parseEmailAddress(
+                address = "1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx1234@" +
+                    "1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx123." +
+                    "1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx123." +
+                    "1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx12",
+                isEmailAddressLengthCheckEnabled = true,
+            )
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(TotalLengthExceeded)
+            prop(EmailAddressParserException::position).isEqualTo(255)
+            hasMessage("The email address exceeds the maximum length of 254 characters")
+        }
+    }
+
+    @Test
+    fun `email exceeds maximum size with length check disabled`() {
+        val input = "1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx1234@" +
+            "1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx123." +
+            "1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx123." +
+            "1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx12"
+
+        val emailAddress = parseEmailAddress(address = input, isEmailAddressLengthCheckEnabled = false)
+
+        assertThat(emailAddress.localPart)
+            .isEqualTo("1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx1234")
+        assertThat(emailAddress.domain).isEqualTo(
+            EmailDomain(
+                "1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx123." +
+                    "1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx123." +
+                    "1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx12",
+            ),
+        )
+        assertThat(emailAddress.address).isEqualTo(input)
+        assertThat(emailAddress.warnings).contains(EmailAddress.Warning.EmailAddressExceedsLengthLimit)
+    }
+
+    @Test
+    fun `input contains additional character`() {
+        assertFailure {
+            parseEmailAddress("test@domain.example#")
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(ExpectedEndOfInput)
+            prop(EmailAddressParserException::position).isEqualTo(19)
+            hasMessage("Expected end of input")
+        }
+    }
+
+    private fun parseEmailAddress(
+        address: String,
+        isLocalPartLengthCheckEnabled: Boolean = false,
+        isEmailAddressLengthCheckEnabled: Boolean = false,
+        isEmptyLocalPartAllowed: Boolean = false,
+        isLocalPartRequiringQuotedStringAllowed: Boolean = isEmptyLocalPartAllowed,
+        isQuotedLocalPartAllowed: Boolean = isLocalPartRequiringQuotedStringAllowed,
+    ): EmailAddress {
+        val config = EmailAddressParserConfig(
+            isLocalPartLengthCheckEnabled,
+            isEmailAddressLengthCheckEnabled,
+            isQuotedLocalPartAllowed,
+            isLocalPartRequiringQuotedStringAllowed,
+            isEmptyLocalPartAllowed,
+        )
+        return EmailAddressParser(address, config).parse()
+    }
+}
diff --git a/core/common/src/test/kotlin/app/k9mail/core/common/mail/EmailAddressTest.kt b/core/common/src/test/kotlin/app/k9mail/core/common/mail/EmailAddressTest.kt
index f37a3b4ef2c6a32c0d9f4b6c4e1c7895bb88848c..4567aba0e6bb1eb172ab9d7d972746738242a764 100644
--- a/core/common/src/test/kotlin/app/k9mail/core/common/mail/EmailAddressTest.kt
+++ b/core/common/src/test/kotlin/app/k9mail/core/common/mail/EmailAddressTest.kt
@@ -1,29 +1,60 @@
 package app.k9mail.core.common.mail
 
+import app.k9mail.core.common.mail.EmailAddress.Warning
 import assertk.assertThat
+import assertk.assertions.containsExactlyInAnyOrder
+import assertk.assertions.isEmpty
 import assertk.assertions.isEqualTo
+import assertk.assertions.isSameAs
 import kotlin.test.Test
-import kotlin.test.assertFails
-
-internal class EmailAddressTest {
 
+class EmailAddressTest {
     @Test
-    fun `should reject blank email address`() {
-        assertFails("Email address must not be blank") {
-            EmailAddress("")
-        }
+    fun `simple email address`() {
+        val domain = EmailDomain("DOMAIN.example")
+        val emailAddress = EmailAddress(localPart = "user", domain = domain)
+
+        assertThat(emailAddress.localPart).isEqualTo("user")
+        assertThat(emailAddress.encodedLocalPart).isEqualTo("user")
+        assertThat(emailAddress.domain).isSameAs(domain)
+        assertThat(emailAddress.address).isEqualTo("user@DOMAIN.example")
+        assertThat(emailAddress.normalizedAddress).isEqualTo("user@domain.example")
+        assertThat(emailAddress.toString()).isEqualTo("user@DOMAIN.example")
+        assertThat(emailAddress.warnings).isEmpty()
     }
 
     @Test
-    fun `should return email address`() {
-        val emailAddress = EmailAddress(EMAIL_ADDRESS)
+    fun `local part that requires use of quoted string`() {
+        val emailAddress = EmailAddress(localPart = "foo bar", domain = EmailDomain("domain.example"))
 
-        val address = emailAddress.address
+        assertThat(emailAddress.localPart).isEqualTo("foo bar")
+        assertThat(emailAddress.encodedLocalPart).isEqualTo("\"foo bar\"")
+        assertThat(emailAddress.address).isEqualTo("\"foo bar\"@domain.example")
+        assertThat(emailAddress.normalizedAddress).isEqualTo("\"foo bar\"@domain.example")
+        assertThat(emailAddress.toString()).isEqualTo("\"foo bar\"@domain.example")
+        assertThat(emailAddress.warnings).containsExactlyInAnyOrder(Warning.QuotedStringInLocalPart)
+    }
 
-        assertThat(address).isEqualTo(EMAIL_ADDRESS)
+    @Test
+    fun `empty local part`() {
+        val emailAddress = EmailAddress(localPart = "", domain = EmailDomain("domain.example"))
+
+        assertThat(emailAddress.localPart).isEqualTo("")
+        assertThat(emailAddress.encodedLocalPart).isEqualTo("\"\"")
+        assertThat(emailAddress.address).isEqualTo("\"\"@domain.example")
+        assertThat(emailAddress.normalizedAddress).isEqualTo("\"\"@domain.example")
+        assertThat(emailAddress.toString()).isEqualTo("\"\"@domain.example")
+        assertThat(emailAddress.warnings).containsExactlyInAnyOrder(
+            Warning.QuotedStringInLocalPart,
+            Warning.EmptyLocalPart,
+        )
     }
 
-    private companion object {
-        private const val EMAIL_ADDRESS = "email@example.com"
+    @Test
+    fun `equals() does case-insensitive domain comparison`() {
+        val emailAddress1 = EmailAddress(localPart = "user", domain = EmailDomain("domain.example"))
+        val emailAddress2 = EmailAddress(localPart = "user", domain = EmailDomain("DOMAIN.example"))
+
+        assertThat(emailAddress2).isEqualTo(emailAddress1)
     }
 }
diff --git a/core/common/src/test/kotlin/app/k9mail/core/common/mail/EmailDomainParserTest.kt b/core/common/src/test/kotlin/app/k9mail/core/common/mail/EmailDomainParserTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c157dc4b2fd6846489c34a6e2b21b696bd904fd9
--- /dev/null
+++ b/core/common/src/test/kotlin/app/k9mail/core/common/mail/EmailDomainParserTest.kt
@@ -0,0 +1,88 @@
+package app.k9mail.core.common.mail
+
+import app.k9mail.core.common.mail.EmailAddressParserError.DnsLabelLengthExceeded
+import app.k9mail.core.common.mail.EmailAddressParserError.DomainLengthExceeded
+import app.k9mail.core.common.mail.EmailAddressParserError.ExpectedEndOfInput
+import app.k9mail.core.common.mail.EmailAddressParserError.UnexpectedCharacter
+import assertk.all
+import assertk.assertFailure
+import assertk.assertThat
+import assertk.assertions.hasMessage
+import assertk.assertions.isEqualTo
+import assertk.assertions.isInstanceOf
+import assertk.assertions.prop
+import kotlin.test.Test
+
+class EmailDomainParserTest {
+    @Test
+    fun `simple domain`() {
+        val emailDomain = parseEmailDomain("DOMAIN.example")
+
+        assertThat(emailDomain.value).isEqualTo("DOMAIN.example")
+        assertThat(emailDomain.normalized).isEqualTo("domain.example")
+    }
+
+    @Test
+    fun `label starting with hyphen`() {
+        assertFailure {
+            parseEmailDomain("-domain.example")
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(UnexpectedCharacter)
+            prop(EmailAddressParserException::position).isEqualTo(0)
+            hasMessage("Expected 'Let-dig'")
+        }
+    }
+
+    @Test
+    fun `label ending with hyphen`() {
+        assertFailure {
+            parseEmailDomain("domain-.example")
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(UnexpectedCharacter)
+            prop(EmailAddressParserException::position).isEqualTo(7)
+            hasMessage("Expected 'Let-dig'")
+        }
+    }
+
+    @Test
+    fun `label exceeds maximum size`() {
+        assertFailure {
+            parseEmailDomain("1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx1234.example")
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(DnsLabelLengthExceeded)
+            prop(EmailAddressParserException::position).isEqualTo(64)
+            hasMessage("DNS labels exceeds maximum length of 63 characters")
+        }
+    }
+
+    @Test
+    fun `domain exceeds maximum size`() {
+        assertFailure {
+            parseEmailDomain(
+                "1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx123." +
+                    "1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx123." +
+                    "1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx123." +
+                    "1xxxxxxxxx2xxxxxxxxx3xxxxxxxxx4xxxxxxxxx5xxxxxxxxx6xxxxxxxxx12",
+            )
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(DomainLengthExceeded)
+            prop(EmailAddressParserException::position).isEqualTo(254)
+            hasMessage("Domain exceeds maximum length of 253 characters")
+        }
+    }
+
+    @Test
+    fun `input contains additional character`() {
+        assertFailure {
+            parseEmailDomain("domain.example#")
+        }.isInstanceOf<EmailAddressParserException>().all {
+            prop(EmailAddressParserException::error).isEqualTo(ExpectedEndOfInput)
+            prop(EmailAddressParserException::position).isEqualTo(14)
+            hasMessage("Expected end of input")
+        }
+    }
+
+    private fun parseEmailDomain(domain: String): EmailDomain {
+        return EmailDomainParser(domain).parseDomain()
+    }
+}
diff --git a/core/common/src/test/kotlin/app/k9mail/core/common/mail/EmailDomainTest.kt b/core/common/src/test/kotlin/app/k9mail/core/common/mail/EmailDomainTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..f3abd1f596b7f10bd37a78153aa67a1afa795b98
--- /dev/null
+++ b/core/common/src/test/kotlin/app/k9mail/core/common/mail/EmailDomainTest.kt
@@ -0,0 +1,24 @@
+package app.k9mail.core.common.mail
+
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import kotlin.test.Test
+
+class EmailDomainTest {
+    @Test
+    fun `simple domain`() {
+        val domain = EmailDomain("DOMAIN.example")
+
+        assertThat(domain.value).isEqualTo("DOMAIN.example")
+        assertThat(domain.normalized).isEqualTo("domain.example")
+        assertThat(domain.toString()).isEqualTo("DOMAIN.example")
+    }
+
+    @Test
+    fun `equals() does case-insensitive comparison`() {
+        val domain1 = EmailDomain("domain.example")
+        val domain2 = EmailDomain("DOMAIN.example")
+
+        assertThat(domain2).isEqualTo(domain1)
+    }
+}
diff --git a/core/common/src/test/kotlin/app/k9mail/core/common/net/DomainTest.kt b/core/common/src/test/kotlin/app/k9mail/core/common/net/DomainTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..7dbdd73979760e2be7b2c62b95a1d2b443c9675b
--- /dev/null
+++ b/core/common/src/test/kotlin/app/k9mail/core/common/net/DomainTest.kt
@@ -0,0 +1,25 @@
+package app.k9mail.core.common.net
+
+import assertk.assertFailure
+import assertk.assertThat
+import assertk.assertions.hasMessage
+import assertk.assertions.isEqualTo
+import assertk.assertions.isInstanceOf
+import kotlin.test.Test
+
+class DomainTest {
+    @Test
+    fun `valid domain`() {
+        val domain = Domain("domain.example")
+
+        assertThat(domain.value).isEqualTo("domain.example")
+    }
+
+    @Test
+    fun `invalid domain should throw`() {
+        assertFailure {
+            Domain("invalid domain")
+        }.isInstanceOf<IllegalArgumentException>()
+            .hasMessage("Not a valid domain name: 'invalid domain'")
+    }
+}
diff --git a/core/common/src/test/kotlin/app/k9mail/core/common/net/HostNameUtilsTest.kt b/core/common/src/test/kotlin/app/k9mail/core/common/net/HostNameUtilsTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..e38ef7b8741ff51a74c137bb783b2a7f4b0a542e
--- /dev/null
+++ b/core/common/src/test/kotlin/app/k9mail/core/common/net/HostNameUtilsTest.kt
@@ -0,0 +1,165 @@
+package app.k9mail.core.common.net
+
+import assertk.Assert
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.isNotNull
+import assertk.assertions.isNull
+import kotlin.test.Test
+
+/**
+ * Test data copied from `mailnews/base/test/unit/test_hostnameUtils.js`
+ */
+class HostNameUtilsTest {
+    @Test
+    fun `valid host names`() {
+        assertThat("localhost").isLegalHostName()
+        assertThat("some-server").isLegalHostName()
+        assertThat("server.company.invalid").isLegalHostName()
+        assertThat("server.comp-any.invalid").isLegalHostName()
+        assertThat("server.123.invalid").isLegalHostName()
+        assertThat("1server.123.invalid").isLegalHostName()
+        assertThat("1.2.3.4.5").isLegalHostName()
+        assertThat("very.log.sub.domain.name.invalid").isLegalHostName()
+        assertThat("1234567890").isLegalHostName()
+        assertThat("1234567890.").isLegalHostName()
+        assertThat("server.company.invalid.").isLegalHostName()
+    }
+
+    @Test
+    fun `invalid host names`() {
+        assertThat("").isNotLegalHostName()
+        assertThat("server.badcompany!.invalid").isNotLegalHostName()
+        assertThat("server._badcompany.invalid").isNotLegalHostName()
+        assertThat("server.bad_company.invalid").isNotLegalHostName()
+        assertThat("server.badcompany-.invalid").isNotLegalHostName()
+        assertThat("server.bad company.invalid").isNotLegalHostName()
+        assertThat("server.b…dcompany.invalid").isNotLegalHostName()
+        assertThat(".server.badcompany.invalid").isNotLegalHostName()
+        assertThat("make-this-a-long-host-name-component-that-is-over-63-characters-long.invalid").isNotLegalHostName()
+        assertThat(
+            "append-strings-to-make-this-a-too-long-host-name.that-is-really-over-255-characters-long.invalid." +
+                "append-strings-to-make-this-a-too-long-host-name.that-is-really-over-255-characters-long.invalid." +
+                "append-strings-to-make-this-a-too-long-host-name.that-is-really-over-255-characters-long.invalid." +
+                "append-strings-to-make-this-a-too-long-host-name.that-is-really-over-255-characters-long.invalid",
+        ).isNotLegalHostName()
+    }
+
+    @Test
+    fun `valid IPv4 addresses`() {
+        assertThat("1.2.3.4").isLegalIPv4Address()
+        assertThat("123.245.111.222").isLegalIPv4Address()
+        assertThat("255.255.255.255").isLegalIPv4Address()
+        assertThat("1.2.0.4").isLegalIPv4Address()
+        assertThat("1.2.3.4").isLegalIPv4Address()
+        assertThat("127.1.2.3").isLegalIPv4Address()
+        assertThat("10.1.2.3").isLegalIPv4Address()
+        assertThat("192.168.2.3").isLegalIPv4Address()
+    }
+
+    @Test
+    fun `invalid IPv4 addresses`() {
+        assertThat("1.2.3.4.5").isNotLegalIPv4Address()
+        assertThat("1.2.3").isNotLegalIPv4Address()
+        assertThat("1.2.3.").isNotLegalIPv4Address()
+        assertThat(".1.2.3").isNotLegalIPv4Address()
+        assertThat("1.2.3.256").isNotLegalIPv4Address()
+        assertThat("1.2.3.12345").isNotLegalIPv4Address()
+        assertThat("1.2..123").isNotLegalIPv4Address()
+        assertThat("1").isNotLegalIPv4Address()
+        assertThat("").isNotLegalIPv4Address()
+        assertThat("0.1.2.3").isNotLegalIPv4Address()
+        assertThat("0.0.2.3").isNotLegalIPv4Address()
+        assertThat("0.0.0.0").isNotLegalIPv4Address()
+        assertThat("1.2.3.d").isNotLegalIPv4Address()
+        assertThat("a.b.c.d").isNotLegalIPv4Address()
+        assertThat("a.b.c.d").isNotLegalIPv4Address()
+
+        // Extended formats of IPv4, hex, octal, decimal up to DWORD
+        // We intentionally don't support any of these.
+        assertThat("0xff.0x12.0x45.0x78").isNotLegalIPv4Address()
+        assertThat("01.0123.056.077").isNotLegalIPv4Address()
+        assertThat("0xff.2.3.4").isNotLegalIPv4Address()
+        assertThat("0xff.2.3.077").isNotLegalIPv4Address()
+        assertThat("0x7f.2.3.077").isNotLegalIPv4Address()
+        assertThat("0xZZ.1.2.3").isNotLegalIPv4Address()
+        assertThat("0x00.0123.056.077").isNotLegalIPv4Address()
+        assertThat("0x11.0123.056.078").isNotLegalIPv4Address()
+        assertThat("0x11.0123.056.0789").isNotLegalIPv4Address()
+        assertThat("1234566945").isNotLegalIPv4Address()
+        assertThat("12345").isNotLegalIPv4Address()
+        assertThat("123456789123456").isNotLegalIPv4Address()
+        assertThat("127.1").isNotLegalIPv4Address()
+        assertThat("0x7f.100").isNotLegalIPv4Address()
+        assertThat("0x7f.100.1000").isNotLegalIPv4Address()
+        assertThat("0xff.100.1024").isNotLegalIPv4Address()
+        assertThat("0xC0.0xA8.0x2A48").isNotLegalIPv4Address()
+        assertThat("0xC0.0xA82A48").isNotLegalIPv4Address()
+        assertThat("0xC0A82A48").isNotLegalIPv4Address()
+        assertThat("0324.062477106").isNotLegalIPv4Address()
+        assertThat("0.0.1000").isNotLegalIPv4Address()
+        assertThat("0324.06247710677").isNotLegalIPv4Address()
+    }
+
+    @Test
+    fun `valid IPv6 addresses`() {
+        assertThat("2001:0db8:85a3:0000:0000:8a2e:0370:7334").isNormalizedTo("2001:0db8:85a3:0000:0000:8a2e:0370:7334")
+        assertThat("2001:db8:85a3:0:0:8a2e:370:7334").isNormalizedTo("2001:0db8:85a3:0000:0000:8a2e:0370:7334")
+        assertThat("2001:db8:85a3::8a2e:370:7334").isNormalizedTo("2001:0db8:85a3:0000:0000:8a2e:0370:7334")
+        assertThat("2001:0db8:85a3:0000:0000:8a2e:0370:").isNormalizedTo("2001:0db8:85a3:0000:0000:8a2e:0370:0000")
+        assertThat("::ffff:c000:0280").isNormalizedTo("0000:0000:0000:0000:0000:ffff:c000:0280")
+        assertThat("::ffff:192.0.2.128").isNormalizedTo("0000:0000:0000:0000:0000:ffff:c000:0280")
+        assertThat("2001:db8::1").isNormalizedTo("2001:0db8:0000:0000:0000:0000:0000:0001")
+        assertThat("2001:DB8::1").isNormalizedTo("2001:0db8:0000:0000:0000:0000:0000:0001")
+        assertThat("1:2:3:4:5:6:7:8").isNormalizedTo("0001:0002:0003:0004:0005:0006:0007:0008")
+        assertThat("::1").isNormalizedTo("0000:0000:0000:0000:0000:0000:0000:0001")
+        assertThat("::0000:0000:1").isNormalizedTo("0000:0000:0000:0000:0000:0000:0000:0001")
+    }
+
+    @Test
+    fun `invalid IPv6 addresses`() {
+        assertThat("::").isNotLegalIPv6Address()
+        assertThat("2001:0db8:85a3:0000:0000:8a2e:0370:73346").isNotLegalIPv6Address()
+        assertThat("2001:0db8:85a3:0000:0000:8a2e:0370:7334:1").isNotLegalIPv6Address()
+        assertThat("2001:0db8:85a3:0000:0000:8a2e:0370:7334x").isNotLegalIPv6Address()
+        assertThat("2001:0db8:85a3:0000:0000:8a2e:03707334").isNotLegalIPv6Address()
+        assertThat("2001:0db8:85a3:0000:0000x8a2e:0370:7334").isNotLegalIPv6Address()
+        assertThat("2001:0db8:85a3:0000:0000:::1").isNotLegalIPv6Address()
+        assertThat("2001:0db8:85a3:0000:0000:0000:some:junk").isNotLegalIPv6Address()
+        assertThat("2001:0db8:85a3:0000:0000:0000::192.0.2.359").isNotLegalIPv6Address()
+        assertThat("some::junk").isNotLegalIPv6Address()
+        assertThat("some_junk").isNotLegalIPv6Address()
+    }
+
+    @Test
+    fun cleanUpHostName() {
+        assertThat(HostNameUtils.cleanUpHostName("imap.domain.example ")).isEqualTo("imap.domain.example")
+    }
+}
+
+private fun Assert<String>.isLegalHostName() = given { actual ->
+    assertThat(HostNameUtils.isLegalHostName(actual)).isNotNull()
+    assertThat(HostNameUtils.isLegalHostNameOrIP(actual)).isNotNull()
+}
+
+private fun Assert<String>.isNotLegalHostName() = given { actual ->
+    assertThat(HostNameUtils.isLegalHostName(actual)).isNull()
+}
+
+private fun Assert<String>.isLegalIPv4Address() = given { actual ->
+    assertThat(HostNameUtils.isLegalIPv4Address(actual)).isNotNull()
+    assertThat(HostNameUtils.isLegalIPAddress(actual)).isNotNull()
+}
+
+private fun Assert<String>.isNotLegalIPv4Address() = given { actual ->
+    assertThat(HostNameUtils.isLegalIPv4Address(actual)).isNull()
+}
+
+private fun Assert<String>.isNormalizedTo(normalized: String) = given { actual ->
+    assertThat(HostNameUtils.isLegalIPv6Address(actual)).isEqualTo(normalized)
+    assertThat(HostNameUtils.isLegalHostNameOrIP(actual)).isEqualTo(normalized)
+}
+
+private fun Assert<String>.isNotLegalIPv6Address() = given { actual ->
+    assertThat(HostNameUtils.isLegalIPv6Address(actual)).isNull()
+}
diff --git a/core/common/src/test/kotlin/app/k9mail/core/common/net/HostnameTest.kt b/core/common/src/test/kotlin/app/k9mail/core/common/net/HostnameTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..970c25bae5bc1978d26cc5b3d96dec61c0e250bf
--- /dev/null
+++ b/core/common/src/test/kotlin/app/k9mail/core/common/net/HostnameTest.kt
@@ -0,0 +1,47 @@
+package app.k9mail.core.common.net
+
+import assertk.assertFailure
+import assertk.assertThat
+import assertk.assertions.hasMessage
+import assertk.assertions.isEqualTo
+import assertk.assertions.isInstanceOf
+import kotlin.test.Test
+
+class HostnameTest {
+    @Test
+    fun `valid domain`() {
+        val hostname = Hostname("domain.example")
+
+        assertThat(hostname.value).isEqualTo("domain.example")
+    }
+
+    @Test
+    fun `valid IPv4`() {
+        val hostname = Hostname("127.0.0.1")
+
+        assertThat(hostname.value).isEqualTo("127.0.0.1")
+    }
+
+    @Test
+    fun `valid IPv6`() {
+        val hostname = Hostname("fc00::1")
+
+        assertThat(hostname.value).isEqualTo("fc00::1")
+    }
+
+    @Test
+    fun `invalid domain should throw`() {
+        assertFailure {
+            Hostname("invalid domain")
+        }.isInstanceOf<IllegalArgumentException>()
+            .hasMessage("Not a valid domain or IP: 'invalid domain'")
+    }
+
+    @Test
+    fun `invalid IPv6 should throw`() {
+        assertFailure {
+            Hostname("fc00:1")
+        }.isInstanceOf<IllegalArgumentException>()
+            .hasMessage("Not a valid domain or IP: 'fc00:1'")
+    }
+}
diff --git a/core/common/src/test/kotlin/app/k9mail/core/common/net/PortTest.kt b/core/common/src/test/kotlin/app/k9mail/core/common/net/PortTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..54a01c177cb7246c5d05ce8754e8f02c8c35ba7e
--- /dev/null
+++ b/core/common/src/test/kotlin/app/k9mail/core/common/net/PortTest.kt
@@ -0,0 +1,33 @@
+package app.k9mail.core.common.net
+
+import assertk.assertFailure
+import assertk.assertThat
+import assertk.assertions.hasMessage
+import assertk.assertions.isEqualTo
+import assertk.assertions.isInstanceOf
+import kotlin.test.Test
+
+class PortTest {
+    @Test
+    fun `valid port number`() {
+        val port = Port(993)
+
+        assertThat(port.value).isEqualTo(993)
+    }
+
+    @Test
+    fun `negative port number should throw`() {
+        assertFailure {
+            Port(-1)
+        }.isInstanceOf<IllegalArgumentException>()
+            .hasMessage("Not a valid port number: -1")
+    }
+
+    @Test
+    fun `port number exceeding valid range should throw`() {
+        assertFailure {
+            Port(65536)
+        }.isInstanceOf<IllegalArgumentException>()
+            .hasMessage("Not a valid port number: 65536")
+    }
+}
diff --git a/core/featureflags/build.gradle.kts b/core/featureflags/build.gradle.kts
new file mode 100644
index 0000000000000000000000000000000000000000..cdbc1e9a266ce49fa1c7bad5b27b5c9b0ffb3f46
--- /dev/null
+++ b/core/featureflags/build.gradle.kts
@@ -0,0 +1,8 @@
+plugins {
+    id(ThunderbirdPlugins.Library.jvm)
+    alias(libs.plugins.android.lint)
+}
+
+dependencies {
+    testImplementation(projects.core.testing)
+}
diff --git a/core/featureflags/src/main/kotlin/app/k9mail/core/featureflag/FeatureFlag.kt b/core/featureflags/src/main/kotlin/app/k9mail/core/featureflag/FeatureFlag.kt
new file mode 100644
index 0000000000000000000000000000000000000000..dc29aa50a04f64432b51f6665b19d1bcbf8594a2
--- /dev/null
+++ b/core/featureflags/src/main/kotlin/app/k9mail/core/featureflag/FeatureFlag.kt
@@ -0,0 +1,6 @@
+package app.k9mail.core.featureflag
+
+data class FeatureFlag(
+    val key: FeatureFlagKey,
+    val enabled: Boolean = false,
+)
diff --git a/core/featureflags/src/main/kotlin/app/k9mail/core/featureflag/FeatureFlagFactory.kt b/core/featureflags/src/main/kotlin/app/k9mail/core/featureflag/FeatureFlagFactory.kt
new file mode 100644
index 0000000000000000000000000000000000000000..619d85fe0e93fc8ad24002bb134329a585549b7e
--- /dev/null
+++ b/core/featureflags/src/main/kotlin/app/k9mail/core/featureflag/FeatureFlagFactory.kt
@@ -0,0 +1,5 @@
+package app.k9mail.core.featureflag
+
+fun interface FeatureFlagFactory {
+    fun createFeatureCatalog(): List<FeatureFlag>
+}
diff --git a/core/featureflags/src/main/kotlin/app/k9mail/core/featureflag/FeatureFlagKey.kt b/core/featureflags/src/main/kotlin/app/k9mail/core/featureflag/FeatureFlagKey.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d7901d229a8dc91ffb1b35caa82333ceb5930d83
--- /dev/null
+++ b/core/featureflags/src/main/kotlin/app/k9mail/core/featureflag/FeatureFlagKey.kt
@@ -0,0 +1,4 @@
+package app.k9mail.core.featureflag
+
+@JvmInline
+value class FeatureFlagKey(val key: String)
diff --git a/core/featureflags/src/main/kotlin/app/k9mail/core/featureflag/FeatureFlagProvider.kt b/core/featureflags/src/main/kotlin/app/k9mail/core/featureflag/FeatureFlagProvider.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d6ea69fb39059d20c91640c58a52405300b8b8fa
--- /dev/null
+++ b/core/featureflags/src/main/kotlin/app/k9mail/core/featureflag/FeatureFlagProvider.kt
@@ -0,0 +1,5 @@
+package app.k9mail.core.featureflag
+
+fun interface FeatureFlagProvider {
+    fun provide(key: FeatureFlagKey): FeatureFlagResult
+}
diff --git a/core/featureflags/src/main/kotlin/app/k9mail/core/featureflag/FeatureFlagResult.kt b/core/featureflags/src/main/kotlin/app/k9mail/core/featureflag/FeatureFlagResult.kt
new file mode 100644
index 0000000000000000000000000000000000000000..bafa73e4da00c1f13bc51227823f37838a0efc44
--- /dev/null
+++ b/core/featureflags/src/main/kotlin/app/k9mail/core/featureflag/FeatureFlagResult.kt
@@ -0,0 +1,31 @@
+package app.k9mail.core.featureflag
+
+sealed interface FeatureFlagResult {
+    object Enabled : FeatureFlagResult
+    object Disabled : FeatureFlagResult
+    object Unavailable : FeatureFlagResult
+
+    fun onEnabled(action: () -> Unit): FeatureFlagResult {
+        if (this is Enabled) {
+            action()
+        }
+
+        return this
+    }
+
+    fun onDisabled(action: () -> Unit): FeatureFlagResult {
+        if (this is Disabled) {
+            action()
+        }
+
+        return this
+    }
+
+    fun onUnavailable(action: () -> Unit): FeatureFlagResult {
+        if (this is Unavailable) {
+            action()
+        }
+
+        return this
+    }
+}
diff --git a/core/featureflags/src/main/kotlin/app/k9mail/core/featureflag/InMemoryFeatureFlagProvider.kt b/core/featureflags/src/main/kotlin/app/k9mail/core/featureflag/InMemoryFeatureFlagProvider.kt
new file mode 100644
index 0000000000000000000000000000000000000000..ddbe770eaebd7aba52d7bae3e9fd0cd937d7776c
--- /dev/null
+++ b/core/featureflags/src/main/kotlin/app/k9mail/core/featureflag/InMemoryFeatureFlagProvider.kt
@@ -0,0 +1,17 @@
+package app.k9mail.core.featureflag
+
+class InMemoryFeatureFlagProvider(
+    featureFlagFactory: FeatureFlagFactory,
+) : FeatureFlagProvider {
+
+    private val features: Map<FeatureFlagKey, FeatureFlag> =
+        featureFlagFactory.createFeatureCatalog().associateBy { it.key }
+
+    override fun provide(key: FeatureFlagKey): FeatureFlagResult {
+        return when (features[key]?.enabled) {
+            null -> FeatureFlagResult.Unavailable
+            true -> FeatureFlagResult.Enabled
+            false -> FeatureFlagResult.Disabled
+        }
+    }
+}
diff --git a/core/featureflags/src/test/kotlin/app/k9mail/core/featureflags/FeatureFlagResultTest.kt b/core/featureflags/src/test/kotlin/app/k9mail/core/featureflags/FeatureFlagResultTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..835dbd5d6da52d3304cb8dfdc5b5471bc8cea9dd
--- /dev/null
+++ b/core/featureflags/src/test/kotlin/app/k9mail/core/featureflags/FeatureFlagResultTest.kt
@@ -0,0 +1,60 @@
+package app.k9mail.core.featureflags
+
+import app.k9mail.core.featureflag.FeatureFlagResult
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import org.junit.Test
+
+class FeatureFlagResultTest {
+
+    @Test
+    fun `should only call onEnabled when enabled`() {
+        val testSubject = FeatureFlagResult.Enabled
+
+        var result = ""
+
+        testSubject.onEnabled {
+            result = "enabled"
+        }.onDisabled {
+            result = "disabled"
+        }.onUnavailable {
+            result = "unavailable"
+        }
+
+        assertThat(result).isEqualTo("enabled")
+    }
+
+    @Test
+    fun `should only call onDisabled when disabled`() {
+        val testSubject = FeatureFlagResult.Disabled
+
+        var result = ""
+
+        testSubject.onEnabled {
+            result = "enabled"
+        }.onDisabled {
+            result = "disabled"
+        }.onUnavailable {
+            result = "unavailable"
+        }
+
+        assertThat(result).isEqualTo("disabled")
+    }
+
+    @Test
+    fun `should only call onUnavailable when unavailable`() {
+        val testSubject = FeatureFlagResult.Unavailable
+
+        var result = ""
+
+        testSubject.onEnabled {
+            result = "enabled"
+        }.onDisabled {
+            result = "disabled"
+        }.onUnavailable {
+            result = "unavailable"
+        }
+
+        assertThat(result).isEqualTo("unavailable")
+    }
+}
diff --git a/core/featureflags/src/test/kotlin/app/k9mail/core/featureflags/InMemoryFeatureFlagProviderTest.kt b/core/featureflags/src/test/kotlin/app/k9mail/core/featureflags/InMemoryFeatureFlagProviderTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..4142e77011037787f0f9d4194062636ec2c222f0
--- /dev/null
+++ b/core/featureflags/src/test/kotlin/app/k9mail/core/featureflags/InMemoryFeatureFlagProviderTest.kt
@@ -0,0 +1,61 @@
+package app.k9mail.core.featureflags
+
+import app.k9mail.core.featureflag.FeatureFlag
+import app.k9mail.core.featureflag.FeatureFlagKey
+import app.k9mail.core.featureflag.FeatureFlagResult
+import app.k9mail.core.featureflag.InMemoryFeatureFlagProvider
+import assertk.assertThat
+import assertk.assertions.isInstanceOf
+import org.junit.Test
+
+class InMemoryFeatureFlagProviderTest {
+
+    @Test
+    fun `should return FeatureFlagResult#Enabled when feature is enabled`() {
+        val feature1Key = FeatureFlagKey("feature1")
+        val featureFlagProvider = InMemoryFeatureFlagProvider(
+            featureFlagFactory = {
+                listOf(
+                    FeatureFlag(key = feature1Key, enabled = true),
+                )
+            },
+        )
+
+        val result = featureFlagProvider.provide(feature1Key)
+
+        assertThat(result).isInstanceOf<FeatureFlagResult.Enabled>()
+    }
+
+    @Test
+    fun `should return FeatureFlagResult#Disabled when feature is disabled`() {
+        val feature1Key = FeatureFlagKey("feature1")
+        val featureFlagProvider = InMemoryFeatureFlagProvider(
+            featureFlagFactory = {
+                listOf(
+                    FeatureFlag(key = feature1Key, enabled = false),
+                )
+            },
+        )
+
+        val result = featureFlagProvider.provide(feature1Key)
+
+        assertThat(result).isInstanceOf<FeatureFlagResult.Disabled>()
+    }
+
+    @Test
+    fun `should return FeatureFlagResult#Unavailable when feature is not found`() {
+        val feature1Key = FeatureFlagKey("feature1")
+        val feature2Key = FeatureFlagKey("feature2")
+        val featureFlagProvider = InMemoryFeatureFlagProvider(
+            featureFlagFactory = {
+                listOf(
+                    FeatureFlag(key = feature1Key, enabled = false),
+                )
+            },
+        )
+
+        val result = featureFlagProvider.provide(feature2Key)
+
+        assertThat(result).isInstanceOf<FeatureFlagResult.Unavailable>()
+    }
+}
diff --git a/core/testing/build.gradle.kts b/core/testing/build.gradle.kts
index 93f45909c0a50546b9442c83fad8b98047dc7b61..2b963d7c8b28cc9194b0f3c21e0a810d592f8c6d 100644
--- a/core/testing/build.gradle.kts
+++ b/core/testing/build.gradle.kts
@@ -4,4 +4,5 @@ plugins {
 
 dependencies {
     implementation(libs.assertk)
+    implementation(libs.turbine)
 }
diff --git a/core/testing/src/main/kotlin/assertk/assertions/TurbineExtensions.kt b/core/testing/src/main/kotlin/assertk/assertions/TurbineExtensions.kt
new file mode 100644
index 0000000000000000000000000000000000000000..56ebc109dc28ee5874d96e58fdc9580d6bbc07f4
--- /dev/null
+++ b/core/testing/src/main/kotlin/assertk/assertions/TurbineExtensions.kt
@@ -0,0 +1,34 @@
+package assertk.assertions
+
+import app.cash.turbine.ReceiveTurbine
+import assertk.Assert
+import assertk.all
+import assertk.assertThat
+
+/**
+ * The `assertThatAndTurbinesConsumed` function ensures that the assertion passed and
+ * all events in the given turbines have been consumed.
+ *
+ * Usage:
+ *  val actualValue: T = getActualValue()
+ *  val turbines: List<ReceiveTurbine<*>> = getTurbines()
+ *  assertThatAndEnsureAllEventsConsumed(actualValue, turbines) {
+ *      // your assertion here
+ *  }
+ *
+ * @param T The type of the actual value.
+ * @param actual The actual value being asserted.
+ * @param turbines The list of ReceiveTurbine instances to check if all events are consumed.
+ * @param assertion An extension function on `Assert<T>`, which is used to define assertions on the actual value.
+ */
+fun <T> assertThatAndTurbinesConsumed(
+    actual: T,
+    turbines: List<ReceiveTurbine<*>>,
+    assertion: Assert<T>.() -> Unit,
+) {
+    assertThat(actual).all {
+        assertion()
+    }
+
+    turbines.forEach { it.ensureAllEventsConsumed() }
+}
diff --git a/core/testing/src/test/kotlin/assertk/assertions/ListExtensionsKtTest.kt b/core/testing/src/test/kotlin/assertk/assertions/ListExtensionsKtTest.kt
index 6978dae9111a5b852f943c1b9d8235e16ad38956..e3626132406212206578d617bb3096631e31119a 100644
--- a/core/testing/src/test/kotlin/assertk/assertions/ListExtensionsKtTest.kt
+++ b/core/testing/src/test/kotlin/assertk/assertions/ListExtensionsKtTest.kt
@@ -1,5 +1,6 @@
 package assertk.assertions
 
+import assertk.assertFailure
 import assertk.assertThat
 import kotlin.test.Test
 
@@ -16,13 +17,8 @@ class ListExtensionsKtTest {
     fun `containsNoDuplicates() should fail with duplicates`() {
         val list = listOf("a", "b", "c", "a", "a")
 
-        assertThat {
+        assertFailure {
             assertThat(list).containsNoDuplicates()
-        }.isFailure()
-            .hasMessage(
-                """
-                expected to contain no duplicates but found: <["a", "a"]>
-                """.trimIndent(),
-            )
+        }.hasMessage("""expected to contain no duplicates but found: <["a", "a"]>""")
     }
 }
diff --git a/core/ui/compose/common/build.gradle.kts b/core/ui/compose/common/build.gradle.kts
index 20f1ad10d1eb0acbffd8cdbf275306c5ee899ee2..d1b76a4dd5ee9c36c768583c00f41e3ad3052c59 100644
--- a/core/ui/compose/common/build.gradle.kts
+++ b/core/ui/compose/common/build.gradle.kts
@@ -6,3 +6,7 @@ android {
     namespace = "app.k9mail.core.ui.compose.common"
     resourcePrefix = "core_ui_common_"
 }
+
+dependencies {
+    testImplementation(projects.core.ui.compose.testing)
+}
diff --git a/core/ui/compose/common/src/main/kotlin/app/k9mail/core/ui/compose/common/activity/LocalActivity.kt b/core/ui/compose/common/src/main/kotlin/app/k9mail/core/ui/compose/common/activity/LocalActivity.kt
new file mode 100644
index 0000000000000000000000000000000000000000..84293ea2928952ca86c813253f8e0f9f4533da94
--- /dev/null
+++ b/core/ui/compose/common/src/main/kotlin/app/k9mail/core/ui/compose/common/activity/LocalActivity.kt
@@ -0,0 +1,21 @@
+package app.k9mail.core.ui.compose.common.activity
+
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionContext
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.staticCompositionLocalOf
+
+val LocalActivity = staticCompositionLocalOf<ComponentActivity> {
+    error("No value for LocalActivity provided")
+}
+
+fun ComponentActivity.setActivityContent(
+    parent: CompositionContext? = null,
+    content: @Composable () -> Unit,
+) {
+    setContent(parent) {
+        CompositionLocalProvider(LocalActivity provides this, content = content)
+    }
+}
diff --git a/core/ui/compose/common/src/main/kotlin/app/k9mail/core/ui/compose/common/mvi/BaseViewModel.kt b/core/ui/compose/common/src/main/kotlin/app/k9mail/core/ui/compose/common/mvi/BaseViewModel.kt
new file mode 100644
index 0000000000000000000000000000000000000000..28f554ba39ea7a662b8e4f510c748032f6143522
--- /dev/null
+++ b/core/ui/compose/common/src/main/kotlin/app/k9mail/core/ui/compose/common/mvi/BaseViewModel.kt
@@ -0,0 +1,57 @@
+package app.k9mail.core.ui.compose.common.mvi
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+
+/**
+ * An abstract base ViewModel that implements [UnidirectionalViewModel] and provides basic
+ * functionality for managing state and effects.
+ *
+ * @param STATE The type that represents the state of the ViewModel. For example, the UI state of a screen can be
+ * represented as a state.
+ * @param EVENT The type that represents user actions that can occur and should be handled by the ViewModel. For
+ * example, a button click can be represented as an event.
+ * @param EFFECT The  type that represents side-effects that can occur in response to the state changes. For example,
+ * a navigation event can be represented as an effect.
+ *
+ * @property initialState The initial [STATE] of the ViewModel.
+ */
+abstract class BaseViewModel<STATE, EVENT, EFFECT>(
+    initialState: STATE,
+) : ViewModel(),
+    UnidirectionalViewModel<STATE, EVENT, EFFECT> {
+
+    private val _state = MutableStateFlow(initialState)
+    override val state: StateFlow<STATE> = _state.asStateFlow()
+
+    private val _effect = MutableSharedFlow<EFFECT>()
+    override val effect: SharedFlow<EFFECT> = _effect.asSharedFlow()
+
+    /**
+     * Updates the [STATE] of the ViewModel.
+     *
+     * @param update A function that takes the current [STATE] and produces a new [STATE].
+     */
+    protected fun updateState(update: (STATE) -> STATE) {
+        _state.update(update)
+    }
+
+    /**
+     * Emits a side effect.
+     *
+     * @param effect The [EFFECT] to emit.
+     */
+    protected fun emitEffect(effect: EFFECT) {
+        viewModelScope.launch {
+            _effect.emit(effect)
+        }
+    }
+}
diff --git a/core/ui/compose/common/src/main/kotlin/app/k9mail/core/ui/compose/common/mvi/UnidirectionalViewModel.kt b/core/ui/compose/common/src/main/kotlin/app/k9mail/core/ui/compose/common/mvi/UnidirectionalViewModel.kt
new file mode 100644
index 0000000000000000000000000000000000000000..f79840deff59f775f23b736bd3e21cf4804cdbb7
--- /dev/null
+++ b/core/ui/compose/common/src/main/kotlin/app/k9mail/core/ui/compose/common/mvi/UnidirectionalViewModel.kt
@@ -0,0 +1,104 @@
+package app.k9mail.core.ui.compose.common.mvi
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.State
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.collectLatest
+
+/**
+ * Interface for a unidirectional view model with side-effects ([EFFECT]). It has a [STATE] and can handle [EVENT]'s.
+ *
+ * @param STATE The type that represents the state of the ViewModel. For example, the UI state of a screen can be
+ * represented as a state.
+ * @param EVENT The type that represents user actions that can occur and should be handled by the ViewModel. For
+ * example, a button click can be represented as an event.
+ * @param EFFECT The  type that represents side-effects that can occur in response to the state changes. For example,
+ * a navigation event can be represented as an effect.
+ */
+interface UnidirectionalViewModel<STATE, EVENT, EFFECT> {
+    /**
+     * The current [STATE] of the view model.
+     */
+    val state: StateFlow<STATE>
+
+    /**
+     * The side-effects ([EFFECT]) produced by the view model.
+     */
+    val effect: SharedFlow<EFFECT>
+
+    /**
+     * Handles an [EVENT] and updates the [STATE] of the view model.
+     *
+     * @param event The [EVENT] to handle.
+     */
+    fun event(event: EVENT)
+}
+
+/**
+ * Data class representing a state and a dispatch function, used for destructuring in [observe].
+ */
+data class StateDispatch<STATE, EVENT>(
+    val state: State<STATE>,
+    val dispatch: (EVENT) -> Unit,
+)
+
+/**
+ * Composable function that observes a UnidirectionalViewModel and handles its side effects.
+ *
+ * Example usage:
+ * ```
+ * @Composable
+ * fun MyScreen(
+ *    onNavigateNext: () -> Unit,
+ *    onNavigateBack: () -> Unit,
+ *    viewModel: MyUnidirectionalViewModel<MyState, MyEvent, MyEffect>,
+ * ) {
+ *    val (state, dispatch) = viewModel.observe { effect ->
+ *      when (effect) {
+ *          MyEffect.OnBackPressed -> onNavigateBack()
+ *          MyEffect.OnNextPressed -> onNavigateNext()
+ *      }
+ *    }
+ *
+ *    MyContent(
+ *      onNextClick = {
+ *          dispatch(MyEvent.OnNext)
+ *      },
+ *      onBackClick = {
+ *          dispatch(MyEvent.OnBack)
+ *      },
+ *      state = state.value,
+ *    )
+ * }
+ * ```
+ *
+ * @param STATE The type that represents the state of the ViewModel.
+ * @param EVENT The type that represents user actions that can occur and should be handled by the ViewModel.
+ * @param EFFECT The  type that represents side-effects that can occur in response to the state changes.
+ *
+ * @param handleEffect A function to handle side effects ([EFFECT]).
+ *
+ * @return A [StateDispatch] containing the state and a dispatch function.
+ */
+@Composable
+inline fun <reified STATE, EVENT, EFFECT> UnidirectionalViewModel<STATE, EVENT, EFFECT>.observe(
+    crossinline handleEffect: (EFFECT) -> Unit,
+): StateDispatch<STATE, EVENT> {
+    val collectedState = state.collectAsStateWithLifecycle()
+
+    val dispatch: (EVENT) -> Unit = { event(it) }
+
+    LaunchedEffect(key1 = effect) {
+        effect.collectLatest {
+            handleEffect(it)
+        }
+    }
+
+    return StateDispatch(
+        state = collectedState,
+        dispatch = dispatch,
+    )
+}
diff --git a/core/ui/compose/common/src/test/kotlin/app/k9mail/core/ui/compose/common/mvi/BaseViewModelTest.kt b/core/ui/compose/common/src/test/kotlin/app/k9mail/core/ui/compose/common/mvi/BaseViewModelTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..6f9ba22630f266b0e767183a588467b58b0d6e24
--- /dev/null
+++ b/core/ui/compose/common/src/test/kotlin/app/k9mail/core/ui/compose/common/mvi/BaseViewModelTest.kt
@@ -0,0 +1,56 @@
+package app.k9mail.core.ui.compose.common.mvi
+
+import app.cash.turbine.test
+import app.k9mail.core.ui.compose.testing.MainDispatcherRule
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import kotlinx.coroutines.test.runTest
+import org.junit.Rule
+import org.junit.Test
+
+class BaseViewModelTest {
+
+    @get:Rule
+    val mainDispatcherRule = MainDispatcherRule()
+
+    @Test
+    fun `should emit initial state`() = runTest {
+        val viewModel = TestBaseViewModel()
+        assertThat(viewModel.state.value).isEqualTo("Initial state")
+    }
+
+    @Test
+    fun `should update state`() = runTest {
+        val viewModel = TestBaseViewModel()
+
+        viewModel.event("Test event")
+
+        assertThat(viewModel.state.value).isEqualTo("Test event")
+
+        viewModel.event("Another test event")
+
+        assertThat(viewModel.state.value).isEqualTo("Another test event")
+    }
+
+    @Test
+    fun `should emit effects`() = runTest {
+        val viewModel = TestBaseViewModel()
+
+        viewModel.effect.test {
+            viewModel.event("Test effect")
+
+            assertThat(awaitItem()).isEqualTo("Test effect")
+
+            viewModel.event("Another test effect")
+
+            assertThat(awaitItem()).isEqualTo("Another test effect")
+        }
+    }
+
+    private class TestBaseViewModel : BaseViewModel<String, String, String>("Initial state") {
+        override fun event(event: String) {
+            updateState { event }
+            emitEffect(event)
+        }
+    }
+}
diff --git a/core/ui/compose/common/src/test/kotlin/app/k9mail/core/ui/compose/common/mvi/UnidirectionalViewModelKtTest.kt b/core/ui/compose/common/src/test/kotlin/app/k9mail/core/ui/compose/common/mvi/UnidirectionalViewModelKtTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..7d039b5a32c732d95a80f95853c9378bf8fabc37
--- /dev/null
+++ b/core/ui/compose/common/src/test/kotlin/app/k9mail/core/ui/compose/common/mvi/UnidirectionalViewModelKtTest.kt
@@ -0,0 +1,78 @@
+package app.k9mail.core.ui.compose.common.mvi
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import app.k9mail.core.ui.compose.testing.ComposeTest
+import app.k9mail.core.ui.compose.testing.MainDispatcherRule
+import app.k9mail.core.ui.compose.testing.setContent
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.runTest
+import org.junit.Rule
+import org.junit.Test
+
+class UnidirectionalViewModelKtTest : ComposeTest() {
+
+    @get:Rule
+    val mainDispatcherRule = MainDispatcherRule()
+
+    @Test
+    fun `observe should emit state changes, allow event dispatch and expose effects`() = runTest {
+        val viewModel = TestViewModel()
+        val effects = mutableListOf<TestEffect>()
+        lateinit var stateDispatch: StateDispatch<TestState, TestEvent>
+
+        setContent {
+            stateDispatch = viewModel.observe { effect ->
+                effects.add(effect)
+            }
+        }
+
+        val (state, dispatch) = stateDispatch
+
+        // Initial state
+        assertThat(state.value.data).isEqualTo("TestState: Initial")
+
+        // Dispatch an event
+        dispatch(TestEvent("Event 1"))
+
+        assertThat(state.value.data).isEqualTo("TestState: Event 1")
+        assertThat(effects.last().result).isEqualTo("TestEffect: Event 1")
+
+        // Dispatch another event
+        dispatch(TestEvent("Event 2"))
+
+        assertThat(state.value.data).isEqualTo("TestState: Event 2")
+        assertThat(effects.last().result).isEqualTo("TestEffect: Event 2")
+    }
+
+    private data class TestState(val data: String)
+    private data class TestEvent(val action: String)
+    private data class TestEffect(val result: String)
+
+    private class TestViewModel(
+        initialState: TestState = TestState("TestState: Initial"),
+    ) : ViewModel(), UnidirectionalViewModel<TestState, TestEvent, TestEffect> {
+
+        private val _state = MutableStateFlow(initialState)
+        override val state: StateFlow<TestState> = _state.asStateFlow()
+
+        private val _effect = MutableSharedFlow<TestEffect>()
+        override val effect: SharedFlow<TestEffect> = _effect.asSharedFlow()
+
+        override fun event(event: TestEvent) {
+            _state.update { it.copy(data = "TestState: ${event.action}") }
+            viewModelScope.launch {
+                _effect.emit(TestEffect(result = "TestEffect: ${event.action}"))
+            }
+        }
+    }
+}
diff --git a/core/ui/compose/designsystem/build.gradle.kts b/core/ui/compose/designsystem/build.gradle.kts
index 2abfd60ebb9dfe5382b735c63efefcf1f18b3dc0..10362d9198bc10d07f58a398b3ff8b42cd95d737 100644
--- a/core/ui/compose/designsystem/build.gradle.kts
+++ b/core/ui/compose/designsystem/build.gradle.kts
@@ -10,7 +10,6 @@ android {
 dependencies {
     api(projects.core.ui.compose.theme)
     implementation(libs.androidx.compose.material)
-    implementation(libs.androidx.compose.material.icons.extended)
 
     testImplementation(projects.core.ui.compose.testing)
 }
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/Divider.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/Divider.kt
new file mode 100644
index 0000000000000000000000000000000000000000..ef63cf3fcdfc01137cecbc883733d53f545d7476
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/Divider.kt
@@ -0,0 +1,48 @@
+package app.k9mail.core.ui.compose.designsystem.atom
+
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+import androidx.compose.material.Divider as MaterialDivider
+
+@Composable
+fun Divider(
+    modifier: Modifier = Modifier,
+    color: Color = MaterialTheme.colors.onSurface.copy(alpha = DIVIDER_ALPHA),
+    thickness: Dp = 1.dp,
+    startIndent: Dp = 0.dp,
+) {
+    MaterialDivider(
+        modifier = modifier,
+        color = color,
+        thickness = thickness,
+        startIndent = startIndent,
+    )
+}
+
+private const val DIVIDER_ALPHA = 0.12f
+
+@Preview(showBackground = true)
+@Composable
+internal fun DividerPreview() {
+    PreviewWithThemes {
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(MainTheme.spacings.double),
+        ) {
+            Divider(
+                modifier = Modifier.fillMaxWidth(),
+            )
+        }
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/Icon.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/Icon.kt
new file mode 100644
index 0000000000000000000000000000000000000000..df0bb7febaeabfafdcc1c9101e4f10bed89892c3
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/Icon.kt
@@ -0,0 +1,47 @@
+package app.k9mail.core.ui.compose.designsystem.atom
+
+import androidx.compose.material.LocalContentAlpha
+import androidx.compose.material.LocalContentColor
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.theme.Icons
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+import androidx.compose.material.Icon as MaterialIcon
+
+@Composable
+fun Icon(
+    imageVector: ImageVector,
+    modifier: Modifier = Modifier,
+    tint: Color = LocalContentColor.current.copy(alpha = LocalContentAlpha.current),
+) {
+    MaterialIcon(
+        imageVector = imageVector,
+        contentDescription = null,
+        modifier = modifier,
+        tint = tint,
+    )
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun IconPreview() {
+    PreviewWithThemes {
+        Icon(
+            imageVector = Icons.Filled.error,
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun IconTintedPreview() {
+    PreviewWithThemes {
+        Icon(
+            imageVector = Icons.Filled.error,
+            tint = Color.Magenta,
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/Surface.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/Surface.kt
index 663a2453bcc670738acffed089fde098a00cffd5..ead36785b86aad167df48420765a423edc0e2964 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/Surface.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/Surface.kt
@@ -1,11 +1,15 @@
 package app.k9mail.core.ui.compose.designsystem.atom
 
-import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.requiredHeight
+import androidx.compose.foundation.layout.requiredWidth
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.RectangleShape
+import androidx.compose.ui.graphics.Shape
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
 import app.k9mail.core.ui.compose.theme.MainTheme
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
 import androidx.compose.material.Surface as MaterialSurface
@@ -13,12 +17,14 @@ import androidx.compose.material.Surface as MaterialSurface
 @Composable
 fun Surface(
     modifier: Modifier = Modifier,
+    shape: Shape = RectangleShape,
     color: Color = MainTheme.colors.surface,
     elevation: Dp = MainTheme.elevations.default,
     content: @Composable () -> Unit,
 ) {
     MaterialSurface(
         modifier = modifier,
+        shape = shape,
         content = content,
         elevation = elevation,
         color = color,
@@ -30,8 +36,27 @@ fun Surface(
 internal fun SurfacePreview() {
     PreviewWithThemes {
         Surface(
-            modifier = Modifier.fillMaxSize(),
+            modifier = Modifier
+                .requiredHeight(100.dp)
+                .requiredWidth(100.dp),
             content = {},
         )
     }
 }
+
+@Preview(showBackground = true)
+@Composable
+internal fun SurfaceWithShapePreview() {
+    PreviewWithThemes {
+        Background {
+            Surface(
+                modifier = Modifier
+                    .requiredHeight(MainTheme.sizes.larger)
+                    .requiredWidth(MainTheme.sizes.larger),
+                shape = MainTheme.shapes.small,
+                color = MainTheme.colors.primary,
+                content = {},
+            )
+        }
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/Switch.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/Switch.kt
new file mode 100644
index 0000000000000000000000000000000000000000..1c449c3bb03f61a7a1198edac0cd8b02e9683055
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/Switch.kt
@@ -0,0 +1,45 @@
+package app.k9mail.core.ui.compose.designsystem.atom
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+import androidx.compose.material.Switch as MaterialSwitch
+
+@Composable
+fun Switch(
+    checked: Boolean,
+    onCheckedChange: (Boolean) -> Unit,
+    modifier: Modifier = Modifier,
+    enabled: Boolean = true,
+) {
+    MaterialSwitch(
+        checked = checked,
+        onCheckedChange = onCheckedChange,
+        modifier = modifier,
+        enabled = enabled,
+    )
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun SwitchPreview() {
+    PreviewWithThemes {
+        Switch(
+            checked = true,
+            onCheckedChange = {},
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun SwitchDisabledPreview() {
+    PreviewWithThemes {
+        Switch(
+            checked = true,
+            onCheckedChange = {},
+            enabled = false,
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/Button.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/Button.kt
index 4b9754d1de0f237145d31cfed05862e8ac7107fa..5165145b8b60f03751cc1ff0834d9d4c2a0a9df9 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/Button.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/Button.kt
@@ -4,8 +4,10 @@ import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.material.ButtonDefaults
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.tooling.preview.Preview
 import app.k9mail.core.ui.compose.designsystem.atom.text.TextButton
+import app.k9mail.core.ui.compose.theme.MainTheme
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
 import androidx.compose.material.Button as MaterialButton
 
@@ -15,13 +17,16 @@ fun Button(
     onClick: () -> Unit,
     modifier: Modifier = Modifier,
     enabled: Boolean = true,
+    color: Color? = null,
     contentPadding: PaddingValues = buttonContentPadding(),
 ) {
     MaterialButton(
         onClick = onClick,
         modifier = modifier,
         enabled = enabled,
-        colors = ButtonDefaults.buttonColors(),
+        colors = ButtonDefaults.buttonColors(
+            backgroundColor = color ?: MainTheme.colors.primary,
+        ),
         contentPadding = contentPadding,
     ) {
         TextButton(text = text)
@@ -39,6 +44,18 @@ internal fun ButtonPreview() {
     }
 }
 
+@Preview(showBackground = true)
+@Composable
+internal fun ButtonColoredPreview() {
+    PreviewWithThemes {
+        Button(
+            text = "ButtonColored",
+            onClick = {},
+            color = Color.Magenta,
+        )
+    }
+}
+
 @Preview(showBackground = true)
 @Composable
 internal fun ButtonDisabledPreview() {
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/ButtonDefaults.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/ButtonDefaults.kt
index 346441e9fc2a03a39eb4ed29af77892d58dce891..f613fbda11e70153065c1f9803c8ac28af302a3a 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/ButtonDefaults.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/ButtonDefaults.kt
@@ -2,12 +2,18 @@ package app.k9mail.core.ui.compose.designsystem.atom.button
 
 import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.runtime.Composable
+import androidx.compose.ui.unit.Dp
 import app.k9mail.core.ui.compose.theme.MainTheme
 
 @Composable
-fun buttonContentPadding(): PaddingValues = PaddingValues(
-    start = MainTheme.spacings.quadruple,
-    top = MainTheme.spacings.default,
-    end = MainTheme.spacings.quadruple,
-    bottom = MainTheme.spacings.default,
+fun buttonContentPadding(
+    start: Dp = MainTheme.spacings.quadruple,
+    top: Dp = MainTheme.spacings.default,
+    end: Dp = MainTheme.spacings.quadruple,
+    bottom: Dp = MainTheme.spacings.default,
+): PaddingValues = PaddingValues(
+    start = start,
+    top = top,
+    end = end,
+    bottom = bottom,
 )
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/ButtonIcon.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/ButtonIcon.kt
new file mode 100644
index 0000000000000000000000000000000000000000..128d4e9d89998abe01cc58027a06b88456d63cbe
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/ButtonIcon.kt
@@ -0,0 +1,41 @@
+package app.k9mail.core.ui.compose.designsystem.atom.button
+
+import androidx.compose.foundation.layout.size
+import androidx.compose.material.Icon
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.theme.Icons
+import app.k9mail.core.ui.compose.theme.MainTheme
+import androidx.compose.material.IconButton as MaterialIconButton
+
+@Composable
+fun ButtonIcon(
+    onClick: () -> Unit,
+    imageVector: ImageVector,
+    modifier: Modifier = Modifier,
+    enabled: Boolean = true,
+    contentDescription: String? = null,
+) {
+    MaterialIconButton(
+        onClick = onClick,
+        modifier = modifier,
+        enabled = enabled,
+    ) {
+        Icon(
+            modifier = Modifier.size(MainTheme.sizes.icon),
+            imageVector = imageVector,
+            contentDescription = contentDescription,
+        )
+    }
+}
+
+@Preview
+@Composable
+internal fun ButtonIconPreview() {
+    ButtonIcon(
+        onClick = { },
+        imageVector = Icons.Filled.user,
+    )
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/ButtonOutlined.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/ButtonOutlined.kt
index 3f0944bd61f18eac5c1ce05204f875822a9ca186..fcde407636e41a69541711915b77c723861f1978 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/ButtonOutlined.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/ButtonOutlined.kt
@@ -19,6 +19,7 @@ fun ButtonOutlined(
     onClick: () -> Unit,
     modifier: Modifier = Modifier,
     enabled: Boolean = true,
+    color: Color? = null,
     contentPadding: PaddingValues = buttonContentPadding(),
 ) {
     MaterialOutlinedButton(
@@ -26,12 +27,13 @@ fun ButtonOutlined(
         modifier = modifier,
         enabled = enabled,
         colors = ButtonDefaults.outlinedButtonColors(
+            contentColor = color ?: MainTheme.colors.primary,
             backgroundColor = Color.Transparent,
         ),
         border = BorderStroke(
             width = 1.dp,
             color = if (enabled) {
-                MainTheme.colors.primary
+                color ?: MainTheme.colors.primary
             } else {
                 MainTheme.colors.onSurface.copy(
                     alpha = 0.12f,
@@ -55,6 +57,18 @@ internal fun ButtonOutlinedPreview() {
     }
 }
 
+@Preview(showBackground = true)
+@Composable
+internal fun ButtonOutlinedColoredPreview() {
+    PreviewWithThemes {
+        ButtonOutlined(
+            text = "ButtonOutlinedColored",
+            onClick = {},
+            color = Color.Magenta,
+        )
+    }
+}
+
 @Preview(showBackground = true)
 @Composable
 internal fun ButtonOutlinedDisabledPreview() {
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/ButtonText.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/ButtonText.kt
index 2ab02ca07adac3e91a1f6674ffcd4fe1c2c12645..be9a029fceeb556403614f008d439c9e1fc78ce1 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/ButtonText.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/button/ButtonText.kt
@@ -4,8 +4,10 @@ import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.material.ButtonDefaults
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.tooling.preview.Preview
 import app.k9mail.core.ui.compose.designsystem.atom.text.TextButton
+import app.k9mail.core.ui.compose.theme.MainTheme
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
 import androidx.compose.material.TextButton as MaterialTextButton
 
@@ -15,13 +17,16 @@ fun ButtonText(
     onClick: () -> Unit,
     modifier: Modifier = Modifier,
     enabled: Boolean = true,
+    color: Color? = null,
     contentPadding: PaddingValues = buttonContentPadding(),
 ) {
     MaterialTextButton(
         onClick = onClick,
         modifier = modifier,
         enabled = enabled,
-        colors = ButtonDefaults.textButtonColors(),
+        colors = ButtonDefaults.textButtonColors(
+            contentColor = color ?: MainTheme.colors.primary,
+        ),
         contentPadding = contentPadding,
     ) {
         TextButton(text = text)
@@ -39,6 +44,18 @@ internal fun ButtonTextPreview() {
     }
 }
 
+@Preview(showBackground = true)
+@Composable
+internal fun ButtonTextColoredPreview() {
+    PreviewWithThemes {
+        ButtonText(
+            text = "ButtonTextColored",
+            onClick = {},
+            color = Color.Magenta,
+        )
+    }
+}
+
 @Preview(showBackground = true)
 @Composable
 internal fun ButtonTextDisabledPreview() {
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextBody1.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextBody1.kt
index 4c604aaa72e0cd25779e25c4b44a873de2f012a0..09cacd61ee08098ef45a4ee80f929c6458010e95 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextBody1.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextBody1.kt
@@ -2,6 +2,13 @@ package app.k9mail.core.ui.compose.designsystem.atom.text
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.tooling.preview.Preview
 import app.k9mail.core.ui.compose.theme.MainTheme
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
@@ -11,11 +18,31 @@ import androidx.compose.material.Text as MaterialText
 fun TextBody1(
     text: String,
     modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
 ) {
     MaterialText(
         text = text,
+        modifier = modifier,
+        color = color,
+        textAlign = textAlign,
         style = MainTheme.typography.body1,
+    )
+}
+
+@Composable
+fun TextBody1(
+    text: AnnotatedString,
+    modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
+) {
+    MaterialText(
+        text = text,
         modifier = modifier,
+        color = color,
+        textAlign = textAlign,
+        style = MainTheme.typography.body1,
     )
 }
 
@@ -26,3 +53,18 @@ internal fun TextBody1Preview() {
         TextBody1(text = "TextBody1")
     }
 }
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextBody1WithAnnotatedStringPreview() {
+    PreviewWithThemes {
+        TextBody1(
+            text = buildAnnotatedString {
+                append("Normal")
+                withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+                    append("Annotated")
+                }
+            },
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextBody2.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextBody2.kt
index dc125a153c480793e7683b42dc63846927e76eca..6b2397da4ef047c5363ffc8035ed7c10f79adbef 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextBody2.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextBody2.kt
@@ -2,6 +2,13 @@ package app.k9mail.core.ui.compose.designsystem.atom.text
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.tooling.preview.Preview
 import app.k9mail.core.ui.compose.theme.MainTheme
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
@@ -11,11 +18,31 @@ import androidx.compose.material.Text as MaterialText
 fun TextBody2(
     text: String,
     modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
 ) {
     MaterialText(
         text = text,
+        modifier = modifier,
+        color = color,
+        textAlign = textAlign,
         style = MainTheme.typography.body2,
+    )
+}
+
+@Composable
+fun TextBody2(
+    text: AnnotatedString,
+    modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
+) {
+    MaterialText(
+        text = text,
         modifier = modifier,
+        color = color,
+        textAlign = textAlign,
+        style = MainTheme.typography.body2,
     )
 }
 
@@ -26,3 +53,18 @@ internal fun TextBody2Preview() {
         TextBody2(text = "TextBody2")
     }
 }
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextBody2WithAnnotatedStringPreview() {
+    PreviewWithThemes {
+        TextBody2(
+            text = buildAnnotatedString {
+                append("Normal")
+                withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+                    append("Annotated")
+                }
+            },
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextButton.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextButton.kt
index 31ac9ad99b7c385768c19bc5a4e18903e59bf54c..a0f5619f5adb594825f3fab54320623162e9f835 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextButton.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextButton.kt
@@ -2,6 +2,13 @@ package app.k9mail.core.ui.compose.designsystem.atom.text
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.tooling.preview.Preview
 import app.k9mail.core.ui.compose.theme.MainTheme
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
@@ -11,11 +18,35 @@ import androidx.compose.material.Text as MaterialText
 fun TextButton(
     text: String,
     modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
 ) {
     MaterialText(
         text = text.uppercase(),
+        modifier = modifier,
+        color = color,
+        textAlign = textAlign,
         style = MainTheme.typography.button,
+    )
+}
+
+@Composable
+fun TextButton(
+    text: AnnotatedString,
+    modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
+) {
+    MaterialText(
+        text = AnnotatedString(
+            text = text.text.uppercase(),
+            spanStyles = text.spanStyles,
+            paragraphStyles = text.paragraphStyles,
+        ),
         modifier = modifier,
+        color = color,
+        textAlign = textAlign,
+        style = MainTheme.typography.button,
     )
 }
 
@@ -26,3 +57,18 @@ internal fun TextButtonPreview() {
         TextButton(text = "TextButton")
     }
 }
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextButtonWithAnnotatedStringPreview() {
+    PreviewWithThemes {
+        TextButton(
+            text = buildAnnotatedString {
+                append("Normal")
+                withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+                    append("Annotated")
+                }
+            },
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextCaption.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextCaption.kt
index 6d81cd36fc0d7f83dd1d863c0dae8eb44a773281..fecb945b416af8e0fb3b0adb0a98a302a3d45c85 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextCaption.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextCaption.kt
@@ -2,6 +2,13 @@ package app.k9mail.core.ui.compose.designsystem.atom.text
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.tooling.preview.Preview
 import app.k9mail.core.ui.compose.theme.MainTheme
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
@@ -11,11 +18,31 @@ import androidx.compose.material.Text as MaterialText
 fun TextCaption(
     text: String,
     modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
 ) {
     MaterialText(
         text = text,
+        modifier = modifier,
+        color = color,
+        textAlign = textAlign,
         style = MainTheme.typography.caption,
+    )
+}
+
+@Composable
+fun TextCaption(
+    text: AnnotatedString,
+    modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
+) {
+    MaterialText(
+        text = text,
         modifier = modifier,
+        color = color,
+        textAlign = textAlign,
+        style = MainTheme.typography.caption,
     )
 }
 
@@ -26,3 +53,18 @@ internal fun TextCaptionPreview() {
         TextCaption(text = "TextCaption")
     }
 }
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextCaptionWithAnnotatedStringPreview() {
+    PreviewWithThemes {
+        TextCaption(
+            text = buildAnnotatedString {
+                append("Normal")
+                withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+                    append("Annotated")
+                }
+            },
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline1.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline1.kt
index bc2f845fd919dfed73a16c2a51ff41a8753bb535..a26fba617d5f693b97b95fe2d4402cd387ebb53b 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline1.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline1.kt
@@ -2,6 +2,13 @@ package app.k9mail.core.ui.compose.designsystem.atom.text
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.tooling.preview.Preview
 import app.k9mail.core.ui.compose.theme.MainTheme
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
@@ -11,11 +18,31 @@ import androidx.compose.material.Text as MaterialText
 fun TextHeadline1(
     text: String,
     modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
 ) {
     MaterialText(
         text = text,
+        modifier = modifier,
+        color = color,
+        textAlign = textAlign,
         style = MainTheme.typography.h1,
+    )
+}
+
+@Composable
+fun TextHeadline1(
+    text: AnnotatedString,
+    modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
+) {
+    MaterialText(
+        text = text,
         modifier = modifier,
+        color = color,
+        textAlign = textAlign,
+        style = MainTheme.typography.h1,
     )
 }
 
@@ -26,3 +53,18 @@ internal fun TextHeadline1Preview() {
         TextHeadline1(text = "TextHeadline1")
     }
 }
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextHeadline1WithAnnotatedStringPreview() {
+    PreviewWithThemes {
+        TextHeadline1(
+            text = buildAnnotatedString {
+                append("Normal")
+                withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+                    append("Annotated")
+                }
+            },
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline2.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline2.kt
index 7227cf21771a1e79e832c0b0051ccdaa8fc9fbc0..eabd641148fbee2e27d1b38568c5af8f3790ecd9 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline2.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline2.kt
@@ -2,6 +2,13 @@ package app.k9mail.core.ui.compose.designsystem.atom.text
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.tooling.preview.Preview
 import app.k9mail.core.ui.compose.theme.MainTheme
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
@@ -11,11 +18,31 @@ import androidx.compose.material.Text as MaterialText
 fun TextHeadline2(
     text: String,
     modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
 ) {
     MaterialText(
         text = text,
+        modifier = modifier,
+        color = color,
+        textAlign = textAlign,
         style = MainTheme.typography.h2,
+    )
+}
+
+@Composable
+fun TextHeadline2(
+    text: AnnotatedString,
+    modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
+) {
+    MaterialText(
+        text = text,
         modifier = modifier,
+        color = color,
+        textAlign = textAlign,
+        style = MainTheme.typography.h2,
     )
 }
 
@@ -26,3 +53,18 @@ internal fun TextHeadline2Preview() {
         TextHeadline2(text = "TextHeadline2")
     }
 }
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextHeadline2WithAnnotatedStringPreview() {
+    PreviewWithThemes {
+        TextHeadline2(
+            text = buildAnnotatedString {
+                append("Normal")
+                withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+                    append("Annotated")
+                }
+            },
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline3.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline3.kt
index 7b4a44d86c86ce5d46ea38581402e25dcf5c0cbd..2ce4893cc39dd4ce183d2bc2c1fa2c4f18ae8923 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline3.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline3.kt
@@ -2,6 +2,13 @@ package app.k9mail.core.ui.compose.designsystem.atom.text
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.tooling.preview.Preview
 import app.k9mail.core.ui.compose.theme.MainTheme
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
@@ -11,11 +18,31 @@ import androidx.compose.material.Text as MaterialText
 fun TextHeadline3(
     text: String,
     modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
 ) {
     MaterialText(
         text = text,
+        modifier = modifier,
+        color = color,
+        textAlign = textAlign,
         style = MainTheme.typography.h3,
+    )
+}
+
+@Composable
+fun TextHeadline3(
+    text: AnnotatedString,
+    modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
+) {
+    MaterialText(
+        text = text,
         modifier = modifier,
+        color = color,
+        textAlign = textAlign,
+        style = MainTheme.typography.h3,
     )
 }
 
@@ -26,3 +53,18 @@ internal fun TextHeadline3Preview() {
         TextHeadline3(text = "TextHeadline3")
     }
 }
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextHeadline3WithAnnotatedStringPreview() {
+    PreviewWithThemes {
+        TextHeadline3(
+            text = buildAnnotatedString {
+                append("Normal")
+                withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+                    append("Annotated")
+                }
+            },
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline4.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline4.kt
index 805eb5fc55695143af51d60c53bb95fc8951be67..3a2b333b64308e3fe0592e6b3302dc896754a3ec 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline4.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline4.kt
@@ -2,6 +2,13 @@ package app.k9mail.core.ui.compose.designsystem.atom.text
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.tooling.preview.Preview
 import app.k9mail.core.ui.compose.theme.MainTheme
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
@@ -11,11 +18,31 @@ import androidx.compose.material.Text as MaterialText
 fun TextHeadline4(
     text: String,
     modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
 ) {
     MaterialText(
         text = text,
+        modifier = modifier,
+        color = color,
+        textAlign = textAlign,
         style = MainTheme.typography.h4,
+    )
+}
+
+@Composable
+fun TextHeadline4(
+    text: AnnotatedString,
+    modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
+) {
+    MaterialText(
+        text = text,
         modifier = modifier,
+        color = color,
+        textAlign = textAlign,
+        style = MainTheme.typography.h4,
     )
 }
 
@@ -26,3 +53,18 @@ internal fun TextHeadline4Preview() {
         TextHeadline4(text = "TextHeadline4")
     }
 }
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextHeadline4WithAnnotatedStringPreview() {
+    PreviewWithThemes {
+        TextHeadline4(
+            text = buildAnnotatedString {
+                append("Normal")
+                withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+                    append("Annotated")
+                }
+            },
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline5.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline5.kt
index 1d0cd722d7ff8afb371dd3372fd1da3d4788bda5..f0cd62de1d76ccb6c76a5e23bdbee6af188b01fb 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline5.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline5.kt
@@ -2,6 +2,13 @@ package app.k9mail.core.ui.compose.designsystem.atom.text
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.tooling.preview.Preview
 import app.k9mail.core.ui.compose.theme.MainTheme
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
@@ -11,11 +18,31 @@ import androidx.compose.material.Text as MaterialText
 fun TextHeadline5(
     text: String,
     modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
 ) {
     MaterialText(
         text = text,
+        modifier = modifier,
+        color = color,
+        textAlign = textAlign,
         style = MainTheme.typography.h5,
+    )
+}
+
+@Composable
+fun TextHeadline5(
+    text: AnnotatedString,
+    modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
+) {
+    MaterialText(
+        text = text,
         modifier = modifier,
+        color = color,
+        textAlign = textAlign,
+        style = MainTheme.typography.h5,
     )
 }
 
@@ -26,3 +53,18 @@ internal fun TextHeadline5Preview() {
         TextHeadline5(text = "TextHeadline5")
     }
 }
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextHeadline5WithAnnotatedStringPreview() {
+    PreviewWithThemes {
+        TextHeadline5(
+            text = buildAnnotatedString {
+                append("Normal")
+                withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+                    append("Annotated")
+                }
+            },
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline6.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline6.kt
index 3b9a9b7f053b155b1b14c5961c0946f6f2313d66..d022369bdf45e749e1c6ca0fa19ef3c2cde40b4d 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline6.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextHeadline6.kt
@@ -2,6 +2,13 @@ package app.k9mail.core.ui.compose.designsystem.atom.text
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.tooling.preview.Preview
 import app.k9mail.core.ui.compose.theme.MainTheme
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
@@ -11,11 +18,31 @@ import androidx.compose.material.Text as MaterialText
 fun TextHeadline6(
     text: String,
     modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
 ) {
     MaterialText(
         text = text,
+        modifier = modifier,
+        color = color,
+        textAlign = textAlign,
         style = MainTheme.typography.h6,
+    )
+}
+
+@Composable
+fun TextHeadline6(
+    text: AnnotatedString,
+    modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
+) {
+    MaterialText(
+        text = text,
         modifier = modifier,
+        color = color,
+        textAlign = textAlign,
+        style = MainTheme.typography.h6,
     )
 }
 
@@ -26,3 +53,18 @@ internal fun TextHeadline6Preview() {
         TextHeadline6(text = "TextHeadline6")
     }
 }
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextHeadline6WithAnnotatedStringPreview() {
+    PreviewWithThemes {
+        TextHeadline6(
+            text = buildAnnotatedString {
+                append("Normal")
+                withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+                    append("Annotated")
+                }
+            },
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextOverline.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextOverline.kt
index 9ec8ae8391c1a3d15da9046d00ae5d21a0af2fac..b1da3d629fc1076210a0de7cca7bdec5a6893972 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextOverline.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextOverline.kt
@@ -2,6 +2,13 @@ package app.k9mail.core.ui.compose.designsystem.atom.text
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.tooling.preview.Preview
 import app.k9mail.core.ui.compose.theme.MainTheme
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
@@ -11,11 +18,35 @@ import androidx.compose.material.Text as MaterialText
 fun TextOverline(
     text: String,
     modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
 ) {
     MaterialText(
         text = text.uppercase(),
+        modifier = modifier,
+        color = color,
+        textAlign = textAlign,
         style = MainTheme.typography.overline,
+    )
+}
+
+@Composable
+fun TextOverline(
+    text: AnnotatedString,
+    modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
+) {
+    MaterialText(
+        text = AnnotatedString(
+            text = text.text.uppercase(),
+            spanStyles = text.spanStyles,
+            paragraphStyles = text.paragraphStyles,
+        ),
         modifier = modifier,
+        color = color,
+        textAlign = textAlign,
+        style = MainTheme.typography.overline,
     )
 }
 
@@ -26,3 +57,18 @@ internal fun TextOverlinePreview() {
         TextOverline(text = "TextOverline")
     }
 }
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextOverlineWithAnnotatedStringPreview() {
+    PreviewWithThemes {
+        TextOverline(
+            text = buildAnnotatedString {
+                append("Normal")
+                withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+                    append("Annotated")
+                }
+            },
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextSubtitle1.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextSubtitle1.kt
index a9d69abbc21df56b8039296456bfb00d77545694..014debaa258117ccd2aabac272d2fa52295306bc 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextSubtitle1.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextSubtitle1.kt
@@ -2,6 +2,13 @@ package app.k9mail.core.ui.compose.designsystem.atom.text
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.tooling.preview.Preview
 import app.k9mail.core.ui.compose.theme.MainTheme
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
@@ -11,11 +18,31 @@ import androidx.compose.material.Text as MaterialText
 fun TextSubtitle1(
     text: String,
     modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
 ) {
     MaterialText(
         text = text,
+        modifier = modifier,
+        color = color,
+        textAlign = textAlign,
         style = MainTheme.typography.subtitle1,
+    )
+}
+
+@Composable
+fun TextSubtitle1(
+    text: AnnotatedString,
+    modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
+) {
+    MaterialText(
+        text = text,
         modifier = modifier,
+        color = color,
+        textAlign = textAlign,
+        style = MainTheme.typography.subtitle1,
     )
 }
 
@@ -26,3 +53,18 @@ internal fun TextSubtitle1Preview() {
         TextSubtitle1(text = "TextSubtitle1")
     }
 }
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextSubtitle1WithAnnotatedStringPreview() {
+    PreviewWithThemes {
+        TextSubtitle1(
+            text = buildAnnotatedString {
+                append("Normal")
+                withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+                    append("Annotated")
+                }
+            },
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextSubtitle2.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextSubtitle2.kt
index fab6c45b147873a576d02d2a5842d3d8dbe32009..5cadbf44bac0aa5992752e9547cac24511dc586b 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextSubtitle2.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/text/TextSubtitle2.kt
@@ -2,6 +2,13 @@ package app.k9mail.core.ui.compose.designsystem.atom.text
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.tooling.preview.Preview
 import app.k9mail.core.ui.compose.theme.MainTheme
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
@@ -11,11 +18,31 @@ import androidx.compose.material.Text as MaterialText
 fun TextSubtitle2(
     text: String,
     modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
 ) {
     MaterialText(
         text = text,
+        modifier = modifier,
+        color = color,
+        textAlign = textAlign,
         style = MainTheme.typography.subtitle2,
+    )
+}
+
+@Composable
+fun TextSubtitle2(
+    text: AnnotatedString,
+    modifier: Modifier = Modifier,
+    color: Color = Color.Unspecified,
+    textAlign: TextAlign? = null,
+) {
+    MaterialText(
+        text = text,
         modifier = modifier,
+        color = color,
+        textAlign = textAlign,
+        style = MainTheme.typography.subtitle2,
     )
 }
 
@@ -26,3 +53,18 @@ internal fun TextSubtitle2Preview() {
         TextSubtitle2(text = "TextSubtitle2")
     }
 }
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextSubtitle2WithAnnotatedStringPreview() {
+    PreviewWithThemes {
+        TextSubtitle2(
+            text = buildAnnotatedString {
+                append("Normal")
+                withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+                    append("Annotated")
+                }
+            },
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldCommon.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldCommon.kt
new file mode 100644
index 0000000000000000000000000000000000000000..fcf3cb0121ae417ad93dc5c80ca238e350194a0d
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldCommon.kt
@@ -0,0 +1,68 @@
+package app.k9mail.core.ui.compose.designsystem.atom.textfield
+
+import androidx.compose.material.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+
+internal fun selectLabel(
+    label: String?,
+    isRequired: Boolean,
+): @Composable (() -> Unit)? {
+    return if (label != null || isRequired) {
+        {
+            TextFieldLabel(label.orEmpty(), isRequired)
+        }
+    } else {
+        null
+    }
+}
+
+@Composable
+internal fun TextFieldLabel(
+    label: String,
+    isRequired: Boolean,
+) {
+    Text(
+        text = if (isRequired) {
+            "$label$ASTERISK"
+        } else {
+            label
+        },
+    )
+}
+
+private const val ASTERISK = "*"
+
+@Preview(showBackground = true)
+@Composable
+fun TextFieldLabelPreview() {
+    PreviewWithThemes {
+        TextFieldLabel(
+            label = "Label",
+            isRequired = false,
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+fun TextFieldLabelRequiredPreview() {
+    PreviewWithThemes {
+        TextFieldLabel(
+            label = "Label",
+            isRequired = true,
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+fun TextFieldLabelRequiredEmptyLabelPreview() {
+    PreviewWithThemes {
+        TextFieldLabel(
+            label = "",
+            isRequired = true,
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlined.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlined.kt
index 251f8a01ef3bb0628f8ddcf93d3b3de93051f151..79ebb45ab1f479ea6b70dea4a827b44e26ef747f 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlined.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlined.kt
@@ -1,41 +1,40 @@
 package app.k9mail.core.ui.compose.designsystem.atom.textfield
 
-import androidx.compose.material.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.designsystem.atom.Icon
+import app.k9mail.core.ui.compose.theme.Icons
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
 import androidx.compose.material.OutlinedTextField as MaterialOutlinedTextField
 
+@Suppress("LongParameterList")
 @Composable
 fun TextFieldOutlined(
     value: String,
     onValueChange: (String) -> Unit,
     modifier: Modifier = Modifier,
-    enabled: Boolean = true,
     label: String? = null,
-    isError: Boolean = false,
+    trailingIcon: @Composable (() -> Unit)? = null,
+    isEnabled: Boolean = true,
+    isReadOnly: Boolean = false,
+    isRequired: Boolean = false,
+    hasError: Boolean = false,
+    isSingleLine: Boolean = true,
 ) {
     MaterialOutlinedTextField(
         value = value,
         onValueChange = onValueChange,
         modifier = modifier,
-        enabled = enabled,
-        label = selectLabel(label),
-        isError = isError,
+        enabled = isEnabled,
+        label = selectLabel(label, isRequired),
+        trailingIcon = trailingIcon,
+        readOnly = isReadOnly,
+        isError = hasError,
+        singleLine = isSingleLine,
     )
 }
 
-private fun selectLabel(label: String?): @Composable (() -> Unit)? {
-    return if (label != null) {
-        {
-            Text(text = label)
-        }
-    } else {
-        null
-    }
-}
-
 @Preview(showBackground = true)
 @Composable
 internal fun TextFieldOutlinedPreview() {
@@ -66,7 +65,7 @@ internal fun TextFieldOutlinedDisabledPreview() {
         TextFieldOutlined(
             value = "Input text",
             onValueChange = {},
-            enabled = false,
+            isEnabled = false,
         )
     }
 }
@@ -78,7 +77,33 @@ internal fun TextFieldOutlinedErrorPreview() {
         TextFieldOutlined(
             value = "Input text",
             onValueChange = {},
-            isError = true,
+            hasError = true,
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextFieldOutlinedRequiredPreview() {
+    PreviewWithThemes {
+        TextFieldOutlined(
+            value = "",
+            onValueChange = {},
+            label = "Label",
+            isRequired = true,
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextFieldOutlinedWithTrailingIconPreview() {
+    PreviewWithThemes {
+        TextFieldOutlined(
+            value = "",
+            onValueChange = {},
+            trailingIcon = { Icon(imageVector = Icons.Filled.user) },
+            isRequired = true,
         )
     }
 }
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedEmailAddress.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedEmailAddress.kt
new file mode 100644
index 0000000000000000000000000000000000000000..abf2d929ba271f496bda28b06d0c3bbce8da8cb3
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedEmailAddress.kt
@@ -0,0 +1,83 @@
+package app.k9mail.core.ui.compose.designsystem.atom.textfield
+
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.input.KeyboardType
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+import androidx.compose.material.OutlinedTextField as MaterialOutlinedTextField
+
+@Suppress("LongParameterList")
+@Composable
+fun TextFieldOutlinedEmailAddress(
+    value: String,
+    onValueChange: (String) -> Unit,
+    modifier: Modifier = Modifier,
+    label: String? = null,
+    isEnabled: Boolean = true,
+    isReadOnly: Boolean = false,
+    isRequired: Boolean = false,
+    hasError: Boolean = false,
+) {
+    MaterialOutlinedTextField(
+        value = value,
+        onValueChange = onValueChange,
+        modifier = modifier,
+        enabled = isEnabled,
+        label = selectLabel(label, isRequired),
+        readOnly = isReadOnly,
+        isError = hasError,
+        keyboardOptions = KeyboardOptions(
+            keyboardType = KeyboardType.Email,
+        ),
+        singleLine = true,
+    )
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextFieldOutlinedEmailAddressPreview() {
+    PreviewWithThemes {
+        TextFieldOutlinedEmailAddress(
+            value = "Input text",
+            onValueChange = {},
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextFieldOutlinedEmailAddressWithLabelPreview() {
+    PreviewWithThemes {
+        TextFieldOutlinedEmailAddress(
+            value = "Input text",
+            label = "Label",
+            onValueChange = {},
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextFieldOutlinedEmailDisabledPreview() {
+    PreviewWithThemes {
+        TextFieldOutlinedEmailAddress(
+            value = "Input text",
+            onValueChange = {},
+            isEnabled = false,
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextFieldOutlinedEmailErrorPreview() {
+    PreviewWithThemes {
+        TextFieldOutlinedEmailAddress(
+            value = "Input text",
+            onValueChange = {},
+            hasError = true,
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedFakeSelect.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedFakeSelect.kt
new file mode 100644
index 0000000000000000000000000000000000000000..2ccee8475c3890bf9adc42ea27ebf7714df61189
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedFakeSelect.kt
@@ -0,0 +1,78 @@
+package app.k9mail.core.ui.compose.designsystem.atom.textfield
+
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.interaction.PressInteraction
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.material.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.designsystem.atom.Icon
+import app.k9mail.core.ui.compose.theme.Icons
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+import androidx.compose.material.OutlinedTextField as MaterialOutlinedTextField
+
+@Composable
+fun TextFieldOutlinedFakeSelect(
+    text: String,
+    onClick: () -> Unit,
+    modifier: Modifier = Modifier,
+    label: String? = null,
+) {
+    MaterialOutlinedTextField(
+        value = text,
+        onValueChange = { },
+        modifier = Modifier
+            .fillMaxWidth()
+            .then(modifier),
+        readOnly = true,
+        label = optionalLabel(label),
+        trailingIcon = { Icon(Icons.Outlined.arrowDropDown) },
+        singleLine = true,
+        interactionSource = remember { MutableInteractionSource() }
+            .also { interactionSource ->
+                LaunchedEffect(interactionSource) {
+                    interactionSource.interactions.collect {
+                        if (it is PressInteraction.Release) {
+                            onClick()
+                        }
+                    }
+                }
+            },
+    )
+}
+
+private fun optionalLabel(label: String?): @Composable (() -> Unit)? {
+    return if (label != null) {
+        {
+            Text(label)
+        }
+    } else {
+        null
+    }
+}
+
+@Preview
+@Composable
+internal fun TextFieldOutlinedFakeSelectPreview() {
+    PreviewWithThemes {
+        TextFieldOutlinedFakeSelect(
+            text = "Current value",
+            onClick = {},
+        )
+    }
+}
+
+@Preview
+@Composable
+internal fun TextFieldOutlinedFakeSelectPreviewWithLabel() {
+    PreviewWithThemes {
+        TextFieldOutlinedFakeSelect(
+            text = "Current value",
+            onClick = {},
+            label = "Label",
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedNumber.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedNumber.kt
new file mode 100644
index 0000000000000000000000000000000000000000..25ee4e7a8cece2d264fe6d40831dd5d89b1f9630
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedNumber.kt
@@ -0,0 +1,87 @@
+package app.k9mail.core.ui.compose.designsystem.atom.textfield
+
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.input.KeyboardType
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+import androidx.compose.material.OutlinedTextField as MaterialOutlinedTextField
+
+@Suppress("LongParameterList")
+@Composable
+fun TextFieldOutlinedNumber(
+    value: Long?,
+    onValueChange: (Long?) -> Unit,
+    modifier: Modifier = Modifier,
+    label: String? = null,
+    isEnabled: Boolean = true,
+    isReadOnly: Boolean = false,
+    isRequired: Boolean = false,
+    hasError: Boolean = false,
+) {
+    MaterialOutlinedTextField(
+        value = value?.toString() ?: "",
+        onValueChange = {
+            onValueChange(
+                it.takeIf { it.isNotBlank() }?.toLongOrNull(),
+            )
+        },
+        modifier = modifier,
+        enabled = isEnabled,
+        label = selectLabel(label, isRequired),
+        readOnly = isReadOnly,
+        isError = hasError,
+        keyboardOptions = KeyboardOptions(
+            keyboardType = KeyboardType.NumberPassword,
+        ),
+        singleLine = true,
+    )
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextFieldOutlinedNumberPreview() {
+    PreviewWithThemes {
+        TextFieldOutlinedNumber(
+            value = 123L,
+            onValueChange = {},
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextFieldOutlinedNumberWithLabelPreview() {
+    PreviewWithThemes {
+        TextFieldOutlinedNumber(
+            value = 123L,
+            label = "Label",
+            onValueChange = {},
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextFieldOutlinedNumberDisabledPreview() {
+    PreviewWithThemes {
+        TextFieldOutlinedNumber(
+            value = 123L,
+            onValueChange = {},
+            isEnabled = false,
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextFieldOutlinedNumberErrorPreview() {
+    PreviewWithThemes {
+        TextFieldOutlinedNumber(
+            value = 123L,
+            onValueChange = {},
+            hasError = true,
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/PasswordTextFieldOutlined.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedPassword.kt
similarity index 77%
rename from core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/PasswordTextFieldOutlined.kt
rename to core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedPassword.kt
index 2086682d3553efdac644cca7e90860c2f67bd791..55cb2516082b047bf3ebb670c75353c9dbe299ce 100644
--- a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/PasswordTextFieldOutlined.kt
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedPassword.kt
@@ -3,10 +3,6 @@ package app.k9mail.core.ui.compose.designsystem.atom.textfield
 import androidx.compose.foundation.text.KeyboardOptions
 import androidx.compose.material.Icon
 import androidx.compose.material.IconButton
-import androidx.compose.material.Text
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.Visibility
-import androidx.compose.material.icons.filled.VisibilityOff
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
@@ -19,17 +15,21 @@ import androidx.compose.ui.text.input.PasswordVisualTransformation
 import androidx.compose.ui.text.input.VisualTransformation
 import androidx.compose.ui.tooling.preview.Preview
 import app.k9mail.core.ui.compose.designsystem.R
+import app.k9mail.core.ui.compose.theme.Icons
 import app.k9mail.core.ui.compose.theme.PreviewWithThemes
 import androidx.compose.material.OutlinedTextField as MaterialOutlinedTextField
 
+@Suppress("LongParameterList")
 @Composable
-fun PasswordTextFieldOutlined(
+fun TextFieldOutlinedPassword(
     value: String,
     onValueChange: (String) -> Unit,
     modifier: Modifier = Modifier,
-    enabled: Boolean = true,
     label: String? = null,
-    isError: Boolean = false,
+    isEnabled: Boolean = true,
+    isReadOnly: Boolean = false,
+    isRequired: Boolean = false,
+    hasError: Boolean = false,
 ) {
     var passwordVisibilityState by rememberSaveable { mutableStateOf(false) }
 
@@ -37,16 +37,17 @@ fun PasswordTextFieldOutlined(
         value = value,
         onValueChange = onValueChange,
         modifier = modifier,
-        enabled = enabled,
-        label = selectLabel(label),
+        enabled = isEnabled,
+        label = selectLabel(label, isRequired),
         trailingIcon = selectTrailingIcon(
-            isEnabled = enabled,
+            isEnabled = isEnabled,
             isPasswordVisible = passwordVisibilityState,
             onClick = { passwordVisibilityState = !passwordVisibilityState },
         ),
-        isError = isError,
+        readOnly = isReadOnly,
+        isError = hasError,
         visualTransformation = selectVisualTransformation(
-            isEnabled = enabled,
+            isEnabled = isEnabled,
             isPasswordVisible = passwordVisibilityState,
         ),
         keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Password),
@@ -54,16 +55,6 @@ fun PasswordTextFieldOutlined(
     )
 }
 
-private fun selectLabel(label: String?): @Composable (() -> Unit)? {
-    return if (label != null) {
-        {
-            Text(text = label)
-        }
-    } else {
-        null
-    }
-}
-
 private fun selectTrailingIcon(
     isEnabled: Boolean,
     isPasswordVisible: Boolean,
@@ -73,9 +64,9 @@ private fun selectTrailingIcon(
     return if (hasTrailingIcon) {
         {
             val image = if (isShowPasswordAllowed(isEnabled, isPasswordVisible)) {
-                Icons.Filled.Visibility
+                Icons.Filled.passwordVisibility
             } else {
-                Icons.Filled.VisibilityOff
+                Icons.Filled.passwordVisibilityOff
             }
 
             val description = if (isShowPasswordAllowed(isEnabled, isPasswordVisible)) {
@@ -110,7 +101,7 @@ private fun isShowPasswordAllowed(isEnabled: Boolean, isPasswordVisible: Boolean
 @Composable
 internal fun PasswordTextFieldOutlinedPreview() {
     PreviewWithThemes {
-        PasswordTextFieldOutlined(
+        TextFieldOutlinedPassword(
             value = "Input text",
             onValueChange = {},
         )
@@ -119,9 +110,9 @@ internal fun PasswordTextFieldOutlinedPreview() {
 
 @Preview(showBackground = true)
 @Composable
-internal fun PasswordTextFieldOutlinedWithLabelPreview() {
+internal fun TextFieldOutlinedPasswordWithLabelPreview() {
     PreviewWithThemes {
-        PasswordTextFieldOutlined(
+        TextFieldOutlinedPassword(
             value = "Input text",
             label = "Label",
             onValueChange = {},
@@ -131,24 +122,24 @@ internal fun PasswordTextFieldOutlinedWithLabelPreview() {
 
 @Preview(showBackground = true)
 @Composable
-internal fun PasswordTextFieldOutlinedDisabledPreview() {
+internal fun TextFieldOutlinedPasswordDisabledPreview() {
     PreviewWithThemes {
-        PasswordTextFieldOutlined(
+        TextFieldOutlinedPassword(
             value = "Input text",
             onValueChange = {},
-            enabled = false,
+            isEnabled = false,
         )
     }
 }
 
 @Preview(showBackground = true)
 @Composable
-internal fun PasswordTextFieldOutlinedErrorPreview() {
+internal fun TextFieldOutlinedPasswordErrorPreview() {
     PreviewWithThemes {
-        PasswordTextFieldOutlined(
+        TextFieldOutlinedPassword(
             value = "Input text",
             onValueChange = {},
-            isError = true,
+            hasError = true,
         )
     }
 }
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedSelect.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedSelect.kt
new file mode 100644
index 0000000000000000000000000000000000000000..867030175311b0484d60874239fee316fbf0db98
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedSelect.kt
@@ -0,0 +1,151 @@
+package app.k9mail.core.ui.compose.designsystem.atom.textfield
+
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.material.DropdownMenuItem
+import androidx.compose.material.ExperimentalMaterialApi
+import androidx.compose.material.ExposedDropdownMenuBox
+import androidx.compose.material.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.designsystem.atom.Icon
+import app.k9mail.core.ui.compose.theme.Icons
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.persistentListOf
+import androidx.compose.material.OutlinedTextField as MaterialOutlinedTextField
+
+@Suppress("LongParameterList")
+@Composable
+fun <T> TextFieldOutlinedSelect(
+    options: ImmutableList<T>,
+    selectedOption: T,
+    onValueChange: (T) -> Unit,
+    modifier: Modifier = Modifier,
+    optionToStringTransformation: (T) -> String = { it.toString() },
+    label: String? = null,
+    isEnabled: Boolean = true,
+    isReadOnly: Boolean = false,
+    isRequired: Boolean = false,
+    hasError: Boolean = false,
+) {
+    TextFieldDropDownWrapper(
+        isReadOnlyOrDisabled = isReadOnly || !isEnabled,
+        options = options,
+        optionToStringTransformation = optionToStringTransformation,
+        onValueChange = onValueChange,
+    ) { expanded ->
+        MaterialOutlinedTextField(
+            value = optionToStringTransformation(selectedOption),
+            onValueChange = { },
+            modifier = Modifier
+                .fillMaxWidth()
+                .then(modifier),
+            enabled = isEnabled,
+            readOnly = true,
+            label = selectLabel(label, isRequired),
+            trailingIcon = selectTrailingIcon(expanded),
+            isError = hasError,
+            singleLine = true,
+            interactionSource = remember {
+                MutableInteractionSource()
+            },
+        )
+    }
+}
+
+private fun selectTrailingIcon(
+    isExpanded: Boolean,
+): @Composable () -> Unit {
+    return if (isExpanded) {
+        { Icon(Icons.Outlined.arrowDropUp) }
+    } else {
+        { Icon(Icons.Outlined.arrowDropDown) }
+    }
+}
+
+@Composable
+private fun <T> TextFieldDropDownWrapper(
+    isReadOnlyOrDisabled: Boolean,
+    options: ImmutableList<T>,
+    optionToStringTransformation: (T) -> String,
+    onValueChange: (T) -> Unit,
+    content: @Composable (expanded: Boolean) -> Unit,
+) {
+    if (isReadOnlyOrDisabled) {
+        content(false)
+    } else {
+        DropDownMenu(
+            options = options,
+            optionToStringTransformation = optionToStringTransformation,
+            onValueChange = onValueChange,
+            content = content,
+        )
+    }
+}
+
+@OptIn(ExperimentalMaterialApi::class)
+@Composable
+private fun <T> DropDownMenu(
+    options: ImmutableList<T>,
+    onValueChange: (T) -> Unit,
+    optionToStringTransformation: (T) -> String,
+    content: @Composable (expanded: Boolean) -> Unit,
+) {
+    var expanded = remember { mutableStateOf(false) }
+
+    ExposedDropdownMenuBox(
+        expanded = expanded.value,
+        onExpandedChange = {
+            expanded.value = expanded.value.not()
+        },
+    ) {
+        content(expanded.value)
+
+        ExposedDropdownMenu(
+            expanded = expanded.value,
+            onDismissRequest = {
+                expanded.value = false
+            },
+        ) {
+            options.forEach { option ->
+                DropdownMenuItem(
+                    onClick = {
+                        onValueChange(option)
+                        expanded.value = false
+                    },
+                ) {
+                    Text(text = optionToStringTransformation(option))
+                }
+            }
+        }
+    }
+}
+
+@Preview
+@Composable
+internal fun TextFieldOutlinedSelectPreview() {
+    PreviewWithThemes {
+        TextFieldOutlinedSelect(
+            options = persistentListOf("Option 1", "Option 2", "Option 3"),
+            selectedOption = "Option 1",
+            onValueChange = {},
+        )
+    }
+}
+
+@Preview
+@Composable
+internal fun TextFieldOutlinedSelectPreviewWithLabel() {
+    PreviewWithThemes {
+        TextFieldOutlinedSelect(
+            options = persistentListOf("Option 1", "Option 2", "Option 3"),
+            selectedOption = "Option 1",
+            onValueChange = {},
+            label = "Label",
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/ErrorView.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/ErrorView.kt
new file mode 100644
index 0000000000000000000000000000000000000000..54f7d38c31be6f9c1aad5bfa204d1afc9945b043
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/ErrorView.kt
@@ -0,0 +1,95 @@
+package app.k9mail.core.ui.compose.designsystem.molecule
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material.Icon
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.designsystem.R
+import app.k9mail.core.ui.compose.designsystem.atom.button.ButtonText
+import app.k9mail.core.ui.compose.designsystem.atom.button.buttonContentPadding
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextBody2
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextSubtitle1
+import app.k9mail.core.ui.compose.theme.Icons
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+
+@Composable
+fun ErrorView(
+    title: String,
+    modifier: Modifier = Modifier,
+    message: String? = null,
+    onRetry: () -> Unit = { },
+) {
+    Column(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(
+                vertical = MainTheme.spacings.default,
+                horizontal = MainTheme.spacings.double,
+            )
+            .then(modifier),
+        horizontalAlignment = Alignment.CenterHorizontally,
+        verticalArrangement = Arrangement.spacedBy(MainTheme.spacings.default),
+    ) {
+        Icon(
+            imageVector = Icons.Filled.error,
+            contentDescription = null,
+            tint = MainTheme.colors.error,
+            modifier = Modifier.padding(top = MainTheme.spacings.default),
+        )
+        TextSubtitle1(
+            text = title,
+            modifier = Modifier.padding(bottom = MainTheme.spacings.default),
+        )
+        if (message != null) {
+            TextBody2(
+                text = message,
+                modifier = Modifier
+                    .fillMaxWidth(),
+            )
+        }
+        Row(
+            modifier = Modifier
+                .fillMaxWidth(),
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.End,
+        ) {
+            ButtonText(
+                text = stringResource(id = R.string.designsystem_molecule_error_view_button_retry),
+                onClick = onRetry,
+                contentPadding = buttonContentPadding(
+                    start = MainTheme.spacings.double,
+                    end = MainTheme.spacings.double,
+                ),
+            )
+        }
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun ErrorViewPreview() {
+    PreviewWithThemes {
+        ErrorView(
+            title = "Error",
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun ErrorViewWithMessagePreview() {
+    PreviewWithThemes {
+        ErrorView(
+            title = "Error",
+            message = "Something went wrong.",
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/LoadingView.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/LoadingView.kt
new file mode 100644
index 0000000000000000000000000000000000000000..cb799625b5410837917662f940ff4391b0771ddf
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/LoadingView.kt
@@ -0,0 +1,57 @@
+package app.k9mail.core.ui.compose.designsystem.molecule
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.designsystem.atom.CircularProgressIndicator
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextSubtitle1
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+
+@Composable
+fun LoadingView(
+    modifier: Modifier = Modifier,
+    message: String? = null,
+) {
+    Column(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(MainTheme.spacings.default)
+            .then(modifier),
+        horizontalAlignment = Alignment.CenterHorizontally,
+    ) {
+        if (message != null) {
+            TextSubtitle1(text = message)
+        }
+        Row(
+            modifier = Modifier.height(MainTheme.sizes.larger),
+            verticalAlignment = Alignment.CenterVertically,
+        ) {
+            CircularProgressIndicator()
+        }
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun LoadingViewPreview() {
+    PreviewWithThemes {
+        LoadingView()
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun LoadingViewWithMessagePreview() {
+    PreviewWithThemes {
+        LoadingView(
+            message = "Loading ...",
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/CheckboxInput.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/CheckboxInput.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c8f6c1ecb909e6e25e7b48554c980e1edfa450c8
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/CheckboxInput.kt
@@ -0,0 +1,82 @@
+package app.k9mail.core.ui.compose.designsystem.molecule.input
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.designsystem.atom.Checkbox
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextBody1
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+
+@Composable
+fun CheckboxInput(
+    text: String,
+    checked: Boolean,
+    onCheckedChange: (Boolean) -> Unit,
+    modifier: Modifier = Modifier,
+    errorMessage: String? = null,
+    contentPadding: PaddingValues = inputContentPadding(),
+) {
+    InputLayout(
+        modifier = modifier,
+        contentPadding = contentPadding,
+        errorMessage = errorMessage,
+    ) {
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .clickable { onCheckedChange(!checked) },
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.spacedBy(MainTheme.spacings.half),
+        ) {
+            Checkbox(
+                checked = checked,
+                onCheckedChange = onCheckedChange,
+            )
+            TextBody1(text = text)
+        }
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun CheckboxInputPreview() {
+    PreviewWithThemes {
+        CheckboxInput(
+            text = "CheckboxInput",
+            checked = false,
+            onCheckedChange = {},
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun CheckboxInputWithErrorPreview() {
+    PreviewWithThemes {
+        CheckboxInput(
+            text = "CheckboxInput",
+            checked = false,
+            onCheckedChange = {},
+            errorMessage = "Error message",
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun CheckboxInputCheckedPreview() {
+    PreviewWithThemes {
+        CheckboxInput(
+            text = "CheckboxInput",
+            checked = true,
+            onCheckedChange = {},
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/EmailAddressInput.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/EmailAddressInput.kt
new file mode 100644
index 0000000000000000000000000000000000000000..ace279701e2349c088d1ae87ceebcb8489414dcd
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/EmailAddressInput.kt
@@ -0,0 +1,57 @@
+package app.k9mail.core.ui.compose.designsystem.molecule.input
+
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.designsystem.R
+import app.k9mail.core.ui.compose.designsystem.atom.textfield.TextFieldOutlinedEmailAddress
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+
+@Composable
+fun EmailAddressInput(
+    onEmailAddressChange: (String) -> Unit,
+    modifier: Modifier = Modifier,
+    emailAddress: String = "",
+    errorMessage: String? = null,
+    isEnabled: Boolean = true,
+    contentPadding: PaddingValues = inputContentPadding(),
+) {
+    InputLayout(
+        modifier = modifier,
+        contentPadding = contentPadding,
+        errorMessage = errorMessage,
+    ) {
+        TextFieldOutlinedEmailAddress(
+            value = emailAddress,
+            onValueChange = onEmailAddressChange,
+            label = stringResource(id = R.string.designsystem_molecule_email_address_input_label),
+            isEnabled = isEnabled,
+            hasError = errorMessage != null,
+            modifier = Modifier.fillMaxWidth(),
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun EmailAddressInputPreview() {
+    PreviewWithThemes {
+        EmailAddressInput(
+            onEmailAddressChange = {},
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun EmailAddressInputWithErrorPreview() {
+    PreviewWithThemes {
+        EmailAddressInput(
+            onEmailAddressChange = {},
+            errorMessage = "Email address error",
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/InputDefaults.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/InputDefaults.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c69586b4d707cb0343fc7766b3986ce47bb67005
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/InputDefaults.kt
@@ -0,0 +1,28 @@
+package app.k9mail.core.ui.compose.designsystem.molecule.input
+
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.unit.Dp
+import app.k9mail.core.ui.compose.theme.MainTheme
+
+@Composable
+fun inputContentPadding(
+    start: Dp = MainTheme.spacings.double,
+    top: Dp = MainTheme.spacings.default,
+    end: Dp = MainTheme.spacings.double,
+    bottom: Dp = MainTheme.spacings.default,
+): PaddingValues = PaddingValues(
+    start = start,
+    top = top,
+    end = end,
+    bottom = bottom,
+)
+
+@Composable
+fun inputContentPadding(
+    horizontal: Dp = MainTheme.spacings.double,
+    vertical: Dp = MainTheme.spacings.default,
+): PaddingValues = PaddingValues(
+    horizontal = horizontal,
+    vertical = vertical,
+)
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/InputLayout.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/InputLayout.kt
new file mode 100644
index 0000000000000000000000000000000000000000..466183c9deb976f619535d17bd2dfef702010cc0
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/InputLayout.kt
@@ -0,0 +1,36 @@
+package app.k9mail.core.ui.compose.designsystem.molecule.input
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextCaption
+import app.k9mail.core.ui.compose.theme.MainTheme
+
+@Composable
+internal fun InputLayout(
+    modifier: Modifier = Modifier,
+    contentPadding: PaddingValues = inputContentPadding(),
+    errorMessage: String? = null,
+    content: @Composable () -> Unit,
+) {
+    Column(
+        modifier = Modifier
+            .padding(contentPadding)
+            .fillMaxWidth()
+            .then(modifier),
+    ) {
+        content()
+
+        AnimatedVisibility(visible = errorMessage != null) {
+            TextCaption(
+                text = errorMessage ?: "",
+                modifier = Modifier.padding(start = MainTheme.spacings.double, top = MainTheme.spacings.half),
+                color = MainTheme.colors.error,
+            )
+        }
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/NumberInput.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/NumberInput.kt
new file mode 100644
index 0000000000000000000000000000000000000000..7d08af433a3f9783198bc25c8c8efdad8d38f587
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/NumberInput.kt
@@ -0,0 +1,69 @@
+package app.k9mail.core.ui.compose.designsystem.molecule.input
+
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.designsystem.atom.textfield.TextFieldOutlinedNumber
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+
+@Suppress("LongParameterList")
+@Composable
+fun NumberInput(
+    onValueChange: (Long?) -> Unit,
+    modifier: Modifier = Modifier,
+    value: Long? = null,
+    label: String? = null,
+    isRequired: Boolean = false,
+    errorMessage: String? = null,
+    contentPadding: PaddingValues = inputContentPadding(),
+) {
+    InputLayout(
+        modifier = modifier,
+        contentPadding = contentPadding,
+        errorMessage = errorMessage,
+    ) {
+        TextFieldOutlinedNumber(
+            value = value,
+            onValueChange = onValueChange,
+            label = label,
+            isRequired = isRequired,
+            hasError = errorMessage != null,
+            modifier = Modifier.fillMaxWidth(),
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun IntegerInputPreview() {
+    PreviewWithThemes {
+        NumberInput(
+            onValueChange = {},
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun IntegerInputIsRequiredPreview() {
+    PreviewWithThemes {
+        NumberInput(
+            onValueChange = {},
+            label = "Text input is required",
+            isRequired = true,
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun IntegerInputWithErrorPreview() {
+    PreviewWithThemes {
+        NumberInput(
+            onValueChange = {},
+            errorMessage = "Text input error",
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/PasswordInput.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/PasswordInput.kt
new file mode 100644
index 0000000000000000000000000000000000000000..5b02a347d2bab567188aa9fdf1d1dd4197921150
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/PasswordInput.kt
@@ -0,0 +1,57 @@
+package app.k9mail.core.ui.compose.designsystem.molecule.input
+
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.designsystem.R
+import app.k9mail.core.ui.compose.designsystem.atom.textfield.TextFieldOutlinedPassword
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+
+@Composable
+fun PasswordInput(
+    onPasswordChange: (String) -> Unit,
+    modifier: Modifier = Modifier,
+    password: String = "",
+    isRequired: Boolean = false,
+    errorMessage: String? = null,
+    contentPadding: PaddingValues = inputContentPadding(),
+) {
+    InputLayout(
+        modifier = modifier,
+        contentPadding = contentPadding,
+        errorMessage = errorMessage,
+    ) {
+        TextFieldOutlinedPassword(
+            value = password,
+            onValueChange = onPasswordChange,
+            label = stringResource(id = R.string.designsystem_molecule_password_input_label),
+            isRequired = isRequired,
+            hasError = errorMessage != null,
+            modifier = Modifier.fillMaxWidth(),
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun PasswordInputPreview() {
+    PreviewWithThemes {
+        PasswordInput(
+            onPasswordChange = {},
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun PasswordInputWithErrorPreview() {
+    PreviewWithThemes {
+        PasswordInput(
+            onPasswordChange = {},
+            errorMessage = "Password error",
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/SelectInput.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/SelectInput.kt
new file mode 100644
index 0000000000000000000000000000000000000000..10525ae7c750f368bde1e27dee74bc3277d816b6
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/SelectInput.kt
@@ -0,0 +1,52 @@
+package app.k9mail.core.ui.compose.designsystem.molecule.input
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.designsystem.atom.textfield.TextFieldOutlinedSelect
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.persistentListOf
+
+@Composable
+fun <T> SelectInput(
+    options: ImmutableList<T>,
+    selectedOption: T,
+    onOptionChange: (T) -> Unit,
+    modifier: Modifier = Modifier,
+    optionToStringTransformation: (T) -> String = { it.toString() },
+    label: String? = null,
+    contentPadding: PaddingValues = inputContentPadding(),
+) {
+    Column(
+        modifier = Modifier
+            .padding(contentPadding)
+            .fillMaxWidth()
+            .then(modifier),
+    ) {
+        TextFieldOutlinedSelect(
+            options = options,
+            selectedOption = selectedOption,
+            onValueChange = onOptionChange,
+            modifier = Modifier.fillMaxWidth(),
+            optionToStringTransformation = optionToStringTransformation,
+            label = label,
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun SelectInputPreview() {
+    PreviewWithThemes {
+        SelectInput(
+            options = persistentListOf("Option 1", "Option 2", "Option 3"),
+            selectedOption = "Option 1",
+            onOptionChange = {},
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/SwitchInput.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/SwitchInput.kt
new file mode 100644
index 0000000000000000000000000000000000000000..967c2611ce7ef14236f091b600b918e7870ed304
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/SwitchInput.kt
@@ -0,0 +1,82 @@
+package app.k9mail.core.ui.compose.designsystem.molecule.input
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.designsystem.atom.Switch
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextBody1
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+
+@Composable
+fun SwitchInput(
+    text: String,
+    checked: Boolean,
+    onCheckedChange: (Boolean) -> Unit,
+    modifier: Modifier = Modifier,
+    errorMessage: String? = null,
+    contentPadding: PaddingValues = inputContentPadding(),
+) {
+    InputLayout(
+        modifier = modifier,
+        contentPadding = contentPadding,
+        errorMessage = errorMessage,
+    ) {
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .clickable { onCheckedChange(!checked) },
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.spacedBy(MainTheme.spacings.half),
+        ) {
+            Switch(
+                checked = checked,
+                onCheckedChange = onCheckedChange,
+            )
+            TextBody1(text = text)
+        }
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun SwitchInputPreview() {
+    PreviewWithThemes {
+        SwitchInput(
+            text = "SwitchInput",
+            checked = false,
+            onCheckedChange = {},
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun SwitchInputWithErrorPreview() {
+    PreviewWithThemes {
+        SwitchInput(
+            text = "SwitchInput",
+            checked = false,
+            onCheckedChange = {},
+            errorMessage = "Error message",
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun SwitchInputCheckedPreview() {
+    PreviewWithThemes {
+        SwitchInput(
+            text = "SwitchInput",
+            checked = true,
+            onCheckedChange = {},
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/TextInput.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/TextInput.kt
new file mode 100644
index 0000000000000000000000000000000000000000..1c586d6a7777eaae35d6a5492ee4090bce5741e9
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/molecule/input/TextInput.kt
@@ -0,0 +1,73 @@
+package app.k9mail.core.ui.compose.designsystem.molecule.input
+
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.designsystem.atom.textfield.TextFieldOutlined
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+
+@Suppress("LongParameterList")
+@Composable
+fun TextInput(
+    onTextChange: (String) -> Unit,
+    modifier: Modifier = Modifier,
+    text: String = "",
+    label: String? = null,
+    isRequired: Boolean = false,
+    errorMessage: String? = null,
+    contentPadding: PaddingValues = inputContentPadding(),
+    isSingleLine: Boolean = true,
+    isEnabled: Boolean = true,
+) {
+    InputLayout(
+        modifier = modifier,
+        contentPadding = contentPadding,
+        errorMessage = errorMessage,
+    ) {
+        TextFieldOutlined(
+            value = text,
+            onValueChange = onTextChange,
+            label = label,
+            isEnabled = isEnabled,
+            isRequired = isRequired,
+            hasError = errorMessage != null,
+            isSingleLine = isSingleLine,
+            modifier = Modifier.fillMaxWidth(),
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextInputPreview() {
+    PreviewWithThemes {
+        TextInput(
+            onTextChange = {},
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextInputIsRequiredPreview() {
+    PreviewWithThemes {
+        TextInput(
+            onTextChange = {},
+            label = "Text input is required",
+            isRequired = true,
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun TextInputWithErrorPreview() {
+    PreviewWithThemes {
+        TextInput(
+            onTextChange = {},
+            errorMessage = "Text input error",
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/organism/TopAppBar.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/organism/TopAppBar.kt
new file mode 100644
index 0000000000000000000000000000000000000000..ab54b805e8a72ffdfba8bf12d8d3dd98093bd63b
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/organism/TopAppBar.kt
@@ -0,0 +1,92 @@
+package app.k9mail.core.ui.compose.designsystem.organism
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.RowScope
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material.Icon
+import androidx.compose.material.IconButton
+import androidx.compose.material.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextBody2
+import app.k9mail.core.ui.compose.theme.Icons
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+import androidx.compose.material.TopAppBar as MaterialTopAppBar
+
+@Composable
+fun TopAppBar(
+    title: String,
+    modifier: Modifier = Modifier,
+    subtitle: String? = null,
+    navigationIcon: @Composable (() -> Unit)? = null,
+    actions: @Composable RowScope.() -> Unit = {},
+    titleContentPadding: PaddingValues? = null,
+) {
+    MaterialTopAppBar(
+        title = { TopAppBarTitle(title, subtitle, titleContentPadding) },
+        modifier = modifier,
+        navigationIcon = navigationIcon,
+        actions = actions,
+        backgroundColor = MainTheme.colors.toolbar,
+    )
+}
+
+@Composable
+private fun TopAppBarTitle(
+    title: String,
+    subtitle: String?,
+    titleContentPadding: PaddingValues?,
+) {
+    Column(
+        if (titleContentPadding != null) {
+            Modifier.padding(titleContentPadding)
+        } else {
+            Modifier
+        },
+    ) {
+        Text(text = title)
+        if (subtitle != null) {
+            TextBody2(text = subtitle)
+        }
+    }
+}
+
+@Preview
+@Composable
+internal fun TopAppBarPreview() {
+    PreviewWithThemes {
+        TopAppBar(
+            title = "Title",
+            navigationIcon = {
+                IconButton(onClick = {}) {
+                    Icon(
+                        imageVector = Icons.Outlined.menu,
+                        contentDescription = null,
+                    )
+                }
+            },
+            actions = {
+                IconButton(onClick = {}) {
+                    Icon(
+                        imageVector = Icons.Outlined.menu,
+                        contentDescription = null,
+                    )
+                }
+            },
+        )
+    }
+}
+
+@Preview
+@Composable
+internal fun TopAppBarWithSubtitlePreview() {
+    PreviewWithThemes {
+        TopAppBar(
+            title = "Title",
+            subtitle = "Subtitle",
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/template/ResponsiveWidthContainer.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/template/ResponsiveWidthContainer.kt
new file mode 100644
index 0000000000000000000000000000000000000000..2d9dcb64c4df710ecb31d1536b25257a007ad226
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/template/ResponsiveWidthContainer.kt
@@ -0,0 +1,103 @@
+package app.k9mail.core.ui.compose.designsystem.template
+
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.requiredWidth
+import androidx.compose.material.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import app.k9mail.core.ui.compose.common.DevicePreviews
+import app.k9mail.core.ui.compose.common.window.WindowSizeClass
+import app.k9mail.core.ui.compose.common.window.WindowSizeClass.Compact
+import app.k9mail.core.ui.compose.common.window.WindowSizeClass.Expanded
+import app.k9mail.core.ui.compose.common.window.WindowSizeClass.Medium
+import app.k9mail.core.ui.compose.common.window.getWindowSizeInfo
+import app.k9mail.core.ui.compose.designsystem.atom.Background
+import app.k9mail.core.ui.compose.designsystem.atom.Surface
+import app.k9mail.core.ui.compose.theme.K9Theme
+import app.k9mail.core.ui.compose.theme.MainTheme
+
+/**
+ * A container that adjusts its width depending on the screen size.
+ *
+ * This composable function acts as a wrapper for its content, applying a modifier that changes
+ * the width of the content based on the current screen size. It uses the `getWindowSizeInfo`
+ * function to determine the screen size, and then applies the appropriate modifier.
+ *
+ * @param modifier Any modifier that should be applied to the outer container. This can be used
+ * to add padding, background colors, click events, etc.
+ * @param content The content to be placed inside this container. The content is expected to be
+ * a composable function.
+ *
+ * Example usage:
+ * ```
+ * ResponsiveWidthContainer {
+ *     Text("Hello, World!")
+ * }
+ * ```
+ */
+@Composable
+fun ResponsiveWidthContainer(
+    modifier: Modifier = Modifier,
+    content: @Composable () -> Unit,
+) {
+    val windowSizeInfo = getWindowSizeInfo()
+
+    val responsiveModifier = when (windowSizeInfo.screenWidthSizeClass) {
+        Compact -> Modifier.fillMaxWidth()
+
+        Medium -> Modifier.requiredWidth(WindowSizeClass.COMPACT_MAX_WIDTH.dp)
+
+        Expanded -> Modifier.requiredWidth(WindowSizeClass.MEDIUM_MAX_WIDTH.dp)
+    }
+
+    Box(
+        modifier = Modifier
+            .fillMaxWidth()
+            .then(modifier),
+        contentAlignment = Alignment.TopCenter,
+    ) {
+        Box(
+            modifier = responsiveModifier,
+        ) {
+            content()
+        }
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun ResponsiveWidthContainerK9Preview() {
+    K9Theme {
+        Background {
+            ResponsiveWidthContainer {
+                Surface(
+                    color = MainTheme.colors.error,
+                    modifier = Modifier.fillMaxSize(),
+                ) {
+                    Text("Hello, World!")
+                }
+            }
+        }
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun ResponsiveWidthContainerThunderbirdPreview() {
+    K9Theme {
+        Background {
+            ResponsiveWidthContainer {
+                Surface(
+                    color = MainTheme.colors.error,
+                    modifier = Modifier.fillMaxSize(),
+                ) {
+                    Text("Hello, World!")
+                }
+            }
+        }
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/template/Scaffold.kt b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/template/Scaffold.kt
new file mode 100644
index 0000000000000000000000000000000000000000..414ebdd05ddb5c29ebd78b4bcb13a13b24d7bb9b
--- /dev/null
+++ b/core/ui/compose/designsystem/src/main/kotlin/app/k9mail/core/ui/compose/designsystem/template/Scaffold.kt
@@ -0,0 +1,120 @@
+package app.k9mail.core.ui.compose.designsystem.template
+
+import androidx.compose.foundation.layout.ColumnScope
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material.DrawerState
+import androidx.compose.material.Scaffold
+import androidx.compose.material.rememberScaffoldState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.ui.Modifier
+import app.k9mail.core.ui.compose.common.DevicePreviews
+import app.k9mail.core.ui.compose.designsystem.atom.Surface
+import app.k9mail.core.ui.compose.theme.K9Theme
+import app.k9mail.core.ui.compose.theme.MainTheme
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import androidx.compose.material.FabPosition as MaterialFabPosition
+import androidx.compose.material.Scaffold as MaterialScaffold
+
+@Suppress("LongParameterList")
+@Composable
+fun Scaffold(
+    modifier: Modifier = Modifier,
+    topBar: @Composable (toggleDrawer: () -> Unit) -> Unit = {},
+    bottomBar: @Composable () -> Unit = {},
+    floatingActionButton: @Composable () -> Unit = {},
+    floatingActionButtonPosition: ScaffoldFabPosition = ScaffoldFabPosition.End,
+    drawerContent: @Composable (ColumnScope.(toggleDrawer: () -> Unit) -> Unit)? = null,
+    content: @Composable (PaddingValues) -> Unit,
+) {
+    val scaffoldState = rememberScaffoldState()
+    val coroutineScope = rememberCoroutineScope()
+
+    MaterialScaffold(
+        modifier = modifier,
+        scaffoldState = scaffoldState,
+        topBar = {
+            topBar { toggleDrawer(scaffoldState.drawerState, coroutineScope) }
+        },
+        bottomBar = bottomBar,
+        floatingActionButton = floatingActionButton,
+        floatingActionButtonPosition = floatingActionButtonPosition.toMaterialFabPosition(),
+        drawerContent = drawerContent?.let { providedDrawerContent ->
+            {
+                providedDrawerContent { toggleDrawer(scaffoldState.drawerState, coroutineScope) }
+            }
+        },
+        drawerGesturesEnabled = scaffoldState.drawerState.isOpen,
+        content = content,
+    )
+}
+
+private fun toggleDrawer(
+    drawerState: DrawerState,
+    coroutineScope: CoroutineScope,
+) {
+    coroutineScope.launch {
+        delay(timeMillis = DRAWER_TOGGLE_DELAY)
+        if (drawerState.isClosed) {
+            drawerState.open()
+        } else {
+            drawerState.close()
+        }
+    }
+}
+
+enum class ScaffoldFabPosition {
+    End,
+    Center,
+}
+
+private fun ScaffoldFabPosition.toMaterialFabPosition(): MaterialFabPosition {
+    return when (this) {
+        ScaffoldFabPosition.End -> MaterialFabPosition.End
+        ScaffoldFabPosition.Center -> MaterialFabPosition.Center
+    }
+}
+
+/**
+ * Delay before opening/closing the drawer to avoid the drawer being opened/closed
+ * immediately and give time for the ripple effect to finish.
+ */
+private const val DRAWER_TOGGLE_DELAY = 250L
+
+@Composable
+@DevicePreviews
+internal fun ScaffoldPreview() {
+    K9Theme {
+        Scaffold(
+            topBar = {
+                Surface(
+                    color = MainTheme.colors.error,
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .height(MainTheme.sizes.topBarHeight),
+                ) {}
+            },
+            bottomBar = {
+                Surface(
+                    color = MainTheme.colors.error,
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .height(MainTheme.sizes.bottomBarHeight),
+                ) {}
+            },
+        ) { contentPadding ->
+            Surface(
+                color = MainTheme.colors.info,
+                modifier = Modifier
+                    .fillMaxSize()
+                    .padding(contentPadding),
+            ) {}
+        }
+    }
+}
diff --git a/core/ui/compose/designsystem/src/main/res/values/strings.xml b/core/ui/compose/designsystem/src/main/res/values/strings.xml
index 6d8ca68e1bf2340aae0fd271ad5f8e90c39cb518..d23ac906c833317a496a04b1437c3eb748e35e92 100644
--- a/core/ui/compose/designsystem/src/main/res/values/strings.xml
+++ b/core/ui/compose/designsystem/src/main/res/values/strings.xml
@@ -2,4 +2,7 @@
 <resources>
     <string name="designsystem_atom_password_textfield_hide_password">Hide password</string>
     <string name="designsystem_atom_password_textfield_show_password">Show password</string>
+    <string name="designsystem_molecule_email_address_input_label">Email address</string>
+    <string name="designsystem_molecule_password_input_label">Password</string>
+    <string name="designsystem_molecule_error_view_button_retry">Retry</string>
 </resources>
diff --git a/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/CommonTextFieldTest.kt b/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/CommonTextFieldTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..b8338ee5949a4f5a4d1a2598251a4ef258f89280
--- /dev/null
+++ b/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/CommonTextFieldTest.kt
@@ -0,0 +1,284 @@
+package app.k9mail.core.ui.compose.designsystem.atom.textfield
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.assertIsEnabled
+import androidx.compose.ui.test.assertIsNotEnabled
+import androidx.compose.ui.test.onNodeWithTag
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performClick
+import androidx.compose.ui.test.performTextInput
+import app.k9mail.core.ui.compose.testing.ComposeTest
+import assertk.assertFailure
+import kotlinx.collections.immutable.persistentListOf
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.ParameterizedRobolectricTestRunner
+
+private const val LABEL = "Label"
+
+data class TextFieldConfig(
+    val label: String?,
+    val isEnabled: Boolean?,
+    val isReadOnly: Boolean,
+    val isRequired: Boolean,
+)
+
+data class CommonTextFieldTestData(
+    val name: String,
+    val content: @Composable (
+        modifier: Modifier,
+        textFieldConfig: TextFieldConfig,
+    ) -> Unit,
+)
+
+@RunWith(ParameterizedRobolectricTestRunner::class)
+class CommonTextFieldTest(
+    data: CommonTextFieldTestData,
+) : ComposeTest() {
+
+    private val testSubjectName = data.name
+    private val testSubject = data.content
+
+    @Test
+    fun `should be enabled by default`() = runComposeTest {
+        setContent {
+            testSubject(
+                modifier = Modifier.testTag(testSubjectName),
+                textFieldConfig = TextFieldConfig(
+                    label = null,
+                    isEnabled = null,
+                    isReadOnly = false,
+                    isRequired = false,
+                ),
+            )
+        }
+
+        onNodeWithTag(testSubjectName).assertIsEnabled()
+    }
+
+    @Test
+    fun `should be disabled when enabled is false`() = runComposeTest {
+        setContent {
+            testSubject(
+                modifier = Modifier.testTag(testSubjectName),
+                textFieldConfig = TextFieldConfig(
+                    label = null,
+                    isEnabled = false,
+                    isReadOnly = false,
+                    isRequired = false,
+                ),
+            )
+        }
+
+        onNodeWithTag(testSubjectName).assertIsNotEnabled()
+    }
+
+    @Test
+    fun `should show label when label is not null`() = runComposeTest {
+        setContent {
+            testSubject(
+                modifier = Modifier.testTag(testSubjectName),
+                textFieldConfig = TextFieldConfig(
+                    label = LABEL,
+                    isEnabled = null,
+                    isReadOnly = false,
+                    isRequired = false,
+                ),
+            )
+        }
+
+        onNodeWithText(LABEL).assertIsDisplayed()
+    }
+
+    @Test
+    fun `should show asterisk when isRequired is true`() = runComposeTest {
+        setContent {
+            testSubject(
+                modifier = Modifier.testTag(testSubjectName),
+                textFieldConfig = TextFieldConfig(
+                    label = LABEL,
+                    isEnabled = null,
+                    isReadOnly = false,
+                    isRequired = true,
+                ),
+            )
+        }
+
+        onNodeWithText("$LABEL*").assertIsDisplayed()
+    }
+
+    @Test
+    fun `should not show asterisk when isRequired is false`() = runComposeTest {
+        setContent {
+            testSubject(
+                modifier = Modifier.testTag(testSubjectName),
+                textFieldConfig = TextFieldConfig(
+                    label = LABEL,
+                    isEnabled = null,
+                    isReadOnly = false,
+                    isRequired = false,
+                ),
+            )
+        }
+
+        onNodeWithText("$LABEL*").assertDoesNotExist()
+    }
+
+    @Test
+    fun `should not allow editing when isReadOnly is true`() = runComposeTest {
+        setContent {
+            testSubject(
+                modifier = Modifier.testTag(testSubjectName),
+                textFieldConfig = TextFieldConfig(
+                    label = LABEL,
+                    isEnabled = null,
+                    isReadOnly = true,
+                    isRequired = false,
+                ),
+            )
+        }
+
+        onNodeWithTag(testSubjectName).performClick()
+        assertFailure {
+            onNodeWithText(testSubjectName).performTextInput(" + added text")
+        }
+    }
+
+    companion object {
+        @JvmStatic
+        @ParameterizedRobolectricTestRunner.Parameters(name = "{0}")
+        @Suppress("LongMethod")
+        fun data(): List<CommonTextFieldTestData> = listOf(
+            CommonTextFieldTestData(
+                name = "TextFieldOutlined",
+                content = { modifier, config ->
+                    if (config.isEnabled != null) {
+                        TextFieldOutlined(
+                            value = "",
+                            onValueChange = {},
+                            modifier = modifier,
+                            label = config.label,
+                            isEnabled = config.isEnabled,
+                            isReadOnly = config.isReadOnly,
+                            isRequired = config.isRequired,
+                        )
+                    } else {
+                        TextFieldOutlined(
+                            value = "",
+                            onValueChange = {},
+                            modifier = modifier,
+                            label = config.label,
+                            isRequired = config.isRequired,
+                            isReadOnly = config.isReadOnly,
+                        )
+                    }
+                },
+            ),
+            CommonTextFieldTestData(
+                name = "TextFieldOutlinedPassword",
+                content = { modifier, config ->
+                    if (config.isEnabled != null) {
+                        TextFieldOutlinedPassword(
+                            value = "",
+                            onValueChange = {},
+                            modifier = modifier,
+                            label = config.label,
+                            isEnabled = config.isEnabled,
+                            isReadOnly = config.isReadOnly,
+                            isRequired = config.isRequired,
+                        )
+                    } else {
+                        TextFieldOutlinedPassword(
+                            value = "",
+                            onValueChange = {},
+                            label = config.label,
+                            modifier = modifier,
+                            isRequired = config.isRequired,
+                            isReadOnly = config.isReadOnly,
+                        )
+                    }
+                },
+            ),
+            CommonTextFieldTestData(
+                name = "TextFieldOutlinedEmail",
+                content = { modifier, config ->
+                    if (config.isEnabled != null) {
+                        TextFieldOutlinedEmailAddress(
+                            value = "",
+                            onValueChange = {},
+                            modifier = modifier,
+                            label = config.label,
+                            isEnabled = config.isEnabled,
+                            isReadOnly = config.isReadOnly,
+                            isRequired = config.isRequired,
+                        )
+                    } else {
+                        TextFieldOutlinedEmailAddress(
+                            value = "",
+                            onValueChange = {},
+                            modifier = modifier,
+                            label = config.label,
+                            isRequired = config.isRequired,
+                            isReadOnly = config.isReadOnly,
+                        )
+                    }
+                },
+            ),
+            CommonTextFieldTestData(
+                name = "TextFieldOutlinedNumber",
+                content = { modifier, config ->
+                    if (config.isEnabled != null) {
+                        TextFieldOutlinedNumber(
+                            value = 123L,
+                            onValueChange = {},
+                            modifier = modifier,
+                            label = config.label,
+                            isEnabled = config.isEnabled,
+                            isReadOnly = config.isReadOnly,
+                            isRequired = config.isRequired,
+                        )
+                    } else {
+                        TextFieldOutlinedNumber(
+                            value = 123L,
+                            onValueChange = {},
+                            modifier = modifier,
+                            label = config.label,
+                            isRequired = config.isRequired,
+                            isReadOnly = config.isReadOnly,
+                        )
+                    }
+                },
+            ),
+            CommonTextFieldTestData(
+                name = "TextFieldOutlinedSelect",
+                content = { modifier, config ->
+                    if (config.isEnabled != null) {
+                        TextFieldOutlinedSelect(
+                            options = persistentListOf("option1", "option2"),
+                            selectedOption = "option1",
+                            onValueChange = {},
+                            modifier = modifier,
+                            label = config.label,
+                            isEnabled = config.isEnabled,
+                            isReadOnly = config.isReadOnly,
+                            isRequired = config.isRequired,
+                        )
+                    } else {
+                        TextFieldOutlinedSelect(
+                            options = persistentListOf("option1", "option2"),
+                            selectedOption = "option1",
+                            onValueChange = {},
+                            modifier = modifier,
+                            label = config.label,
+                            isRequired = config.isRequired,
+                            isReadOnly = config.isReadOnly,
+                        )
+                    }
+                },
+            ),
+        )
+    }
+}
diff --git a/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldKtTest.kt b/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldKtTest.kt
deleted file mode 100644
index 086c2bbce9f8ae7e733448885bda648b2d45c75e..0000000000000000000000000000000000000000
--- a/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldKtTest.kt
+++ /dev/null
@@ -1,154 +0,0 @@
-package app.k9mail.core.ui.compose.designsystem.atom.textfield
-
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.platform.testTag
-import androidx.compose.ui.test.assertIsDisplayed
-import androidx.compose.ui.test.assertIsEnabled
-import androidx.compose.ui.test.assertIsNotEnabled
-import androidx.compose.ui.test.onNodeWithTag
-import androidx.compose.ui.test.onNodeWithText
-import androidx.compose.ui.test.performClick
-import androidx.compose.ui.test.performTextInput
-import app.k9mail.core.ui.compose.testing.ComposeTest
-import assertk.assertThat
-import assertk.assertions.isEqualTo
-import org.junit.Test
-import org.junit.runner.RunWith
-import org.robolectric.ParameterizedRobolectricTestRunner
-
-private const val VALUE = "Input text"
-private const val LABEL = "Label"
-
-data class TextFieldTestData(
-    val name: String,
-    val content: @Composable (
-        value: String,
-        onValueChange: (String) -> Unit,
-        modifier: Modifier,
-        enabled: Boolean?,
-        label: String?,
-    ) -> Unit,
-)
-
-@RunWith(ParameterizedRobolectricTestRunner::class)
-class TextFieldKtTest(
-    data: TextFieldTestData,
-) : ComposeTest() {
-
-    private val testSubjectName = data.name
-    private val testSubject = data.content
-
-    @Test
-    fun `should call onValueChange when value changes`() = runComposeTest {
-        var value = VALUE
-        setContent {
-            testSubject(
-                value = value,
-                onValueChange = { value = it },
-                modifier = Modifier.testTag(testSubjectName),
-                enabled = null,
-                label = null,
-            )
-        }
-
-        onNodeWithTag(testSubjectName).performClick()
-        onNodeWithTag(testSubjectName).performTextInput(" + added text")
-
-        assertThat(value).isEqualTo("$VALUE + added text")
-    }
-
-    @Test
-    fun `should be enabled by default`() = runComposeTest {
-        setContent {
-            testSubject(
-                value = VALUE,
-                onValueChange = {},
-                modifier = Modifier.testTag(testSubjectName),
-                enabled = null,
-                label = null,
-            )
-        }
-
-        onNodeWithTag(testSubjectName).assertIsEnabled()
-    }
-
-    @Test
-    fun `should be disabled when enabled is false`() = runComposeTest {
-        setContent {
-            testSubject(
-                value = VALUE,
-                onValueChange = {},
-                modifier = Modifier.testTag(testSubjectName),
-                enabled = false,
-                label = null,
-            )
-        }
-
-        onNodeWithTag(testSubjectName).assertIsNotEnabled()
-    }
-
-    @Test
-    fun `should show label when label is not null`() = runComposeTest {
-        setContent {
-            testSubject(
-                value = VALUE,
-                onValueChange = {},
-                modifier = Modifier.testTag(testSubjectName),
-                enabled = null,
-                label = LABEL,
-            )
-        }
-
-        onNodeWithText(LABEL).assertIsDisplayed()
-    }
-
-    companion object {
-        @JvmStatic
-        @ParameterizedRobolectricTestRunner.Parameters(name = "{0}")
-        fun data(): List<TextFieldTestData> = listOf(
-            TextFieldTestData(
-                name = "TextFieldOutlined",
-                content = { value, onValueChange, modifier, enabled, label ->
-                    if (enabled != null) {
-                        TextFieldOutlined(
-                            value = value,
-                            onValueChange = onValueChange,
-                            modifier = modifier,
-                            enabled = enabled,
-                            label = label,
-                        )
-                    } else {
-                        TextFieldOutlined(
-                            value = value,
-                            onValueChange = onValueChange,
-                            modifier = modifier,
-                            label = label,
-                        )
-                    }
-                },
-            ),
-            TextFieldTestData(
-                name = "PasswordTextFieldOutlined",
-                content = { value, onValueChange, modifier, enabled, label ->
-                    if (enabled != null) {
-                        PasswordTextFieldOutlined(
-                            value = value,
-                            onValueChange = onValueChange,
-                            modifier = modifier,
-                            enabled = enabled,
-                            label = label,
-                        )
-                    } else {
-                        PasswordTextFieldOutlined(
-                            value = value,
-                            onValueChange = onValueChange,
-                            modifier = modifier,
-                            label = label,
-                        )
-                    }
-                },
-            ),
-        )
-    }
-}
diff --git a/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedNumberKtTest.kt b/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedNumberKtTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..342db161f5a131ca7412f009f8c395913907dc22
--- /dev/null
+++ b/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedNumberKtTest.kt
@@ -0,0 +1,85 @@
+package app.k9mail.core.ui.compose.designsystem.atom.textfield
+
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.test.onNodeWithTag
+import androidx.compose.ui.test.performClick
+import androidx.compose.ui.test.performTextClearance
+import androidx.compose.ui.test.performTextInput
+import app.k9mail.core.ui.compose.testing.ComposeTest
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import org.junit.Test
+
+private const val TEST_TAG = "TextFieldOutlinedNumber"
+
+class TextFieldOutlinedNumberKtTest : ComposeTest() {
+
+    @Test
+    fun `should call onValueChange with null when input is empty`() = runComposeTest {
+        var value: Long? = 1L
+        setContent {
+            TextFieldOutlinedNumber(
+                value = value,
+                onValueChange = { value = it },
+                modifier = Modifier.testTag(TEST_TAG),
+            )
+        }
+
+        onNodeWithTag(TEST_TAG).performClick()
+        onNodeWithTag(TEST_TAG).performTextClearance()
+
+        assertThat(value).isEqualTo(null)
+    }
+
+    @Test
+    fun `should call onValueChange when value changes`() = runComposeTest {
+        var value: Long? = 123L
+        setContent {
+            TextFieldOutlinedNumber(
+                value = value,
+                onValueChange = { value = it },
+                modifier = Modifier.testTag(TEST_TAG),
+            )
+        }
+
+        onNodeWithTag(TEST_TAG).performClick()
+        onNodeWithTag(TEST_TAG).performTextInput("456")
+
+        assertThat(value).isEqualTo(123456L)
+    }
+
+    @Test
+    fun `should return null when no number`() = runComposeTest {
+        var value: Long? = 123L
+        setContent {
+            TextFieldOutlinedNumber(
+                value = value,
+                onValueChange = { value = it },
+                modifier = Modifier.testTag(TEST_TAG),
+            )
+        }
+
+        onNodeWithTag(TEST_TAG).performClick()
+        onNodeWithTag(TEST_TAG).performTextInput(",")
+
+        assertThat(value).isEqualTo(null)
+    }
+
+    @Test
+    fun `should return null when input exceeds max long`() = runComposeTest {
+        var value: Long? = null
+        setContent {
+            TextFieldOutlinedNumber(
+                value = value,
+                onValueChange = { value = it },
+                modifier = Modifier.testTag(TEST_TAG),
+            )
+        }
+
+        onNodeWithTag(TEST_TAG).performClick()
+        onNodeWithTag(TEST_TAG).performTextInput("9223372036854775808")
+
+        assertThat(value).isEqualTo(null)
+    }
+}
diff --git a/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/PasswordTextFieldOutlinedKtTest.kt b/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedPasswordKtTest.kt
similarity index 91%
rename from core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/PasswordTextFieldOutlinedKtTest.kt
rename to core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedPasswordKtTest.kt
index d80d36a877aaca5ae51d4b5d10cd151e14256d78..a4bbfa6cfab2950c6c79c7da6bff4fd887cc004d 100644
--- a/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/PasswordTextFieldOutlinedKtTest.kt
+++ b/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedPasswordKtTest.kt
@@ -12,12 +12,12 @@ import org.junit.Test
 
 private const val PASSWORD = "Password input"
 
-class PasswordTextFieldOutlinedKtTest : ComposeTest() {
+class TextFieldOutlinedPasswordKtTest : ComposeTest() {
 
     @Test
     fun `should not display password by default`() = runComposeTest {
         setContent {
-            PasswordTextFieldOutlined(
+            TextFieldOutlinedPassword(
                 value = PASSWORD,
                 onValueChange = {},
             )
@@ -29,7 +29,7 @@ class PasswordTextFieldOutlinedKtTest : ComposeTest() {
     @Test
     fun `should display password when show password is clicked`() = runComposeTest {
         setContent {
-            PasswordTextFieldOutlined(
+            TextFieldOutlinedPassword(
                 value = PASSWORD,
                 onValueChange = {},
             )
@@ -43,7 +43,7 @@ class PasswordTextFieldOutlinedKtTest : ComposeTest() {
     @Test
     fun `should not display password when hide password is clicked`() = runComposeTest {
         setContent {
-            PasswordTextFieldOutlined(
+            TextFieldOutlinedPassword(
                 value = PASSWORD,
                 onValueChange = {},
             )
@@ -58,7 +58,7 @@ class PasswordTextFieldOutlinedKtTest : ComposeTest() {
     @Test
     fun `should display hide password icon when show password is clicked`() = runComposeTest {
         setContent {
-            PasswordTextFieldOutlined(
+            TextFieldOutlinedPassword(
                 value = PASSWORD,
                 onValueChange = {},
             )
@@ -72,7 +72,7 @@ class PasswordTextFieldOutlinedKtTest : ComposeTest() {
     @Test
     fun `should display show password icon when hide password icon is clicked`() = runComposeTest {
         setContent {
-            PasswordTextFieldOutlined(
+            TextFieldOutlinedPassword(
                 value = PASSWORD,
                 onValueChange = {},
             )
diff --git a/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedSelectTest.kt b/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedSelectTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..50ad54da58fd9a22fc9ca287639aa1e46dbe63ee
--- /dev/null
+++ b/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextFieldOutlinedSelectTest.kt
@@ -0,0 +1,68 @@
+package app.k9mail.core.ui.compose.designsystem.atom.textfield
+
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.test.onNodeWithTag
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performClick
+import app.k9mail.core.ui.compose.testing.ComposeTest
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import kotlin.test.Test
+import kotlinx.collections.immutable.persistentListOf
+
+private const val TEST_TAG = "TextFieldOutlinedSelect"
+
+class TextFieldOutlinedSelectTest : ComposeTest() {
+    @Test
+    fun `should call onValueChange when value changes`() = runComposeTest {
+        var value = "option1"
+        setContent {
+            TextFieldOutlinedSelect(
+                options = persistentListOf("option1", "option2"),
+                selectedOption = value,
+                onValueChange = { value = it },
+                modifier = Modifier.testTag(TEST_TAG),
+            )
+        }
+
+        onNodeWithTag(TEST_TAG).performClick()
+
+        onNodeWithText("option2").performClick()
+        assertThat(value).isEqualTo("option2")
+    }
+
+    @Test
+    fun `should not show dropdown when not enabled`() = runComposeTest {
+        setContent {
+            TextFieldOutlinedSelect(
+                options = persistentListOf("option1", "option2"),
+                selectedOption = "option1",
+                onValueChange = {},
+                modifier = Modifier.testTag(TEST_TAG),
+                isEnabled = false,
+            )
+        }
+
+        onNodeWithTag(TEST_TAG).performClick()
+
+        onNodeWithText("option2").assertDoesNotExist()
+    }
+
+    @Test
+    fun `should not show dropdown when read-only`() = runComposeTest {
+        setContent {
+            TextFieldOutlinedSelect(
+                options = persistentListOf("option1", "option2"),
+                selectedOption = "option1",
+                onValueChange = {},
+                modifier = Modifier.testTag(TEST_TAG),
+                isReadOnly = true,
+            )
+        }
+
+        onNodeWithTag(TEST_TAG).performClick()
+
+        onNodeWithText("option2").assertDoesNotExist()
+    }
+}
diff --git a/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextInputTextFieldTest.kt b/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextInputTextFieldTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..7beecff87647d9c18521f8b905eadb16d142dd20
--- /dev/null
+++ b/core/ui/compose/designsystem/src/test/kotlin/app/k9mail/core/ui/compose/designsystem/atom/textfield/TextInputTextFieldTest.kt
@@ -0,0 +1,91 @@
+package app.k9mail.core.ui.compose.designsystem.atom.textfield
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.test.onNodeWithTag
+import androidx.compose.ui.test.performClick
+import androidx.compose.ui.test.performTextInput
+import app.k9mail.core.ui.compose.testing.ComposeTest
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.ParameterizedRobolectricTestRunner
+
+data class TextInputTextFieldTestData(
+    val name: String,
+    val input: String,
+    val content: @Composable (
+        value: String,
+        onValueChange: (String) -> Unit,
+        modifier: Modifier,
+    ) -> Unit,
+)
+
+@RunWith(ParameterizedRobolectricTestRunner::class)
+class TextInputTextFieldTest(
+    data: TextInputTextFieldTestData,
+) : ComposeTest() {
+
+    private val testSubjectName = data.name
+    private val testSubject = data.content
+    private val testInput = data.input
+
+    @Test
+    fun `should call onValueChange when value changes`() = runComposeTest {
+        var value = testInput
+        setContent {
+            testSubject(
+                value = value,
+                onValueChange = { value = it },
+                modifier = Modifier.testTag(testSubjectName),
+            )
+        }
+
+        onNodeWithTag(testSubjectName).performClick()
+        onNodeWithTag(testSubjectName).performTextInput(" + added text")
+
+        assertThat(value).isEqualTo("$testInput + added text")
+    }
+
+    companion object {
+        @JvmStatic
+        @ParameterizedRobolectricTestRunner.Parameters(name = "{0}")
+        fun data(): List<TextInputTextFieldTestData> = listOf(
+            TextInputTextFieldTestData(
+                name = "TextFieldOutlined",
+                input = "value",
+                content = { value, onValueChange: (String) -> Unit, modifier ->
+                    TextFieldOutlined(
+                        value = value,
+                        onValueChange = onValueChange,
+                        modifier = modifier,
+                    )
+                },
+            ),
+            TextInputTextFieldTestData(
+                name = "TextFieldOutlinedPassword",
+                input = "value",
+                content = { value, onValueChange: (String) -> Unit, modifier ->
+                    TextFieldOutlinedPassword(
+                        value = value,
+                        onValueChange = onValueChange,
+                        modifier = modifier,
+                    )
+                },
+            ),
+            TextInputTextFieldTestData(
+                name = "TextFieldOutlinedEmail",
+                input = "value",
+                content = { value, onValueChange: (String) -> Unit, modifier ->
+                    TextFieldOutlinedEmailAddress(
+                        value = value,
+                        onValueChange = onValueChange,
+                        modifier = modifier,
+                    )
+                },
+            ),
+        )
+    }
+}
diff --git a/core/ui/compose/testing/build.gradle.kts b/core/ui/compose/testing/build.gradle.kts
index b72db636647c0def5ad660ec78f7a4bc040d5d95..67284608094e59494eb853a8c473b04b1590b8f1 100644
--- a/core/ui/compose/testing/build.gradle.kts
+++ b/core/ui/compose/testing/build.gradle.kts
@@ -7,6 +7,10 @@ android {
 }
 
 dependencies {
+    api(projects.core.testing)
+    api(libs.turbine)
+    api(libs.assertk)
+
     implementation(projects.core.ui.compose.theme)
     implementation(libs.androidx.compose.material)
 
diff --git a/core/ui/compose/testing/src/main/kotlin/app/k9mail/core/ui/compose/testing/ComposeTest.kt b/core/ui/compose/testing/src/main/kotlin/app/k9mail/core/ui/compose/testing/ComposeTest.kt
index 855d0cc3aed171b74e7eb8c31850f929d8cb0ee8..7868ccb575b91d0e5fa7f5511208a3c4c8e5cec4 100644
--- a/core/ui/compose/testing/src/main/kotlin/app/k9mail/core/ui/compose/testing/ComposeTest.kt
+++ b/core/ui/compose/testing/src/main/kotlin/app/k9mail/core/ui/compose/testing/ComposeTest.kt
@@ -1,8 +1,18 @@
+@file:Suppress("TooManyFunctions")
+
 package app.k9mail.core.ui.compose.testing
 
 import androidx.annotation.StringRes
+import androidx.compose.runtime.Composable
 import androidx.compose.ui.test.junit4.ComposeContentTestRule
 import androidx.compose.ui.test.junit4.createComposeRule
+import androidx.compose.ui.test.onAllNodesWithContentDescription
+import androidx.compose.ui.test.onAllNodesWithTag
+import androidx.compose.ui.test.onAllNodesWithText
+import androidx.compose.ui.test.onNodeWithContentDescription
+import androidx.compose.ui.test.onNodeWithTag
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.onRoot
 import org.junit.Rule
 import org.junit.runner.RunWith
 import org.robolectric.RobolectricTestRunner
@@ -20,3 +30,64 @@ open class ComposeTest {
         testContent()
     }
 }
+
+fun ComposeTest.setContent(content: @Composable () -> Unit) = composeTestRule.setContent(content)
+
+fun ComposeTest.onNodeWithTag(
+    tag: String,
+    useUnmergedTree: Boolean = false,
+) = composeTestRule.onNodeWithTag(tag, useUnmergedTree)
+
+fun ComposeTest.onAllNodesWithTag(
+    tag: String,
+    useUnmergedTree: Boolean = false,
+) = composeTestRule.onAllNodesWithTag(tag, useUnmergedTree)
+
+fun ComposeTest.onNodeWithContentDescription(
+    label: String,
+    substring: Boolean = false,
+    ignoreCase: Boolean = false,
+    useUnmergedTree: Boolean = false,
+) = composeTestRule.onNodeWithContentDescription(label, substring, ignoreCase, useUnmergedTree)
+
+fun ComposeTest.onNodeWithText(
+    text: String,
+    substring: Boolean = false,
+    ignoreCase: Boolean = false,
+    useUnmergedTree: Boolean = false,
+) = composeTestRule.onNodeWithText(text, substring, ignoreCase, useUnmergedTree)
+
+fun ComposeTest.onNodeWithText(
+    @StringRes resourceId: Int,
+    substring: Boolean = false,
+    ignoreCase: Boolean = false,
+    useUnmergedTree: Boolean = false,
+) = composeTestRule.onNodeWithText(getString(resourceId), substring, ignoreCase, useUnmergedTree)
+
+fun ComposeTest.onNodeWithTextIgnoreCase(
+    text: String,
+    substring: Boolean = false,
+    useUnmergedTree: Boolean = false,
+) = composeTestRule.onNodeWithText(text, substring, true, useUnmergedTree)
+
+fun ComposeTest.onNodeWithTextIgnoreCase(
+    @StringRes resourceId: Int,
+    substring: Boolean = false,
+    useUnmergedTree: Boolean = false,
+) = composeTestRule.onNodeWithText(getString(resourceId), substring, true, useUnmergedTree)
+
+fun ComposeTest.onAllNodesWithText(
+    text: String,
+    substring: Boolean = false,
+    ignoreCase: Boolean = false,
+    useUnmergedTree: Boolean = false,
+) = composeTestRule.onAllNodesWithText(text, substring, ignoreCase, useUnmergedTree)
+
+fun ComposeTest.onAllNodesWithContentDescription(
+    label: String,
+    substring: Boolean = false,
+    ignoreCase: Boolean = false,
+    useUnmergedTree: Boolean = false,
+) = composeTestRule.onAllNodesWithContentDescription(label, substring, ignoreCase, useUnmergedTree)
+
+fun ComposeTest.onRoot(useUnmergedTree: Boolean = false) = composeTestRule.onRoot(useUnmergedTree)
diff --git a/core/ui/compose/testing/src/main/kotlin/app/k9mail/core/ui/compose/testing/MainDispatcherRule.kt b/core/ui/compose/testing/src/main/kotlin/app/k9mail/core/ui/compose/testing/MainDispatcherRule.kt
new file mode 100644
index 0000000000000000000000000000000000000000..8b1965edb866ef7eecb0752cd04df0b892931fb4
--- /dev/null
+++ b/core/ui/compose/testing/src/main/kotlin/app/k9mail/core/ui/compose/testing/MainDispatcherRule.kt
@@ -0,0 +1,26 @@
+package app.k9mail.core.ui.compose.testing
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.TestDispatcher
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.setMain
+import org.junit.rules.TestWatcher
+import org.junit.runner.Description
+
+/**
+ * A JUnit rule that swaps the [Dispatchers.Main] dispatcher with a [TestDispatcher] for the duration of the test.
+ */
+@OptIn(ExperimentalCoroutinesApi::class)
+class MainDispatcherRule(
+    val testDispatcher: TestDispatcher = UnconfinedTestDispatcher(),
+) : TestWatcher() {
+    override fun starting(description: Description) {
+        Dispatchers.setMain(testDispatcher)
+    }
+
+    override fun finished(description: Description) {
+        Dispatchers.resetMain()
+    }
+}
diff --git a/core/ui/compose/testing/src/main/kotlin/app/k9mail/core/ui/compose/testing/mvi/EventStateTestUtil.kt b/core/ui/compose/testing/src/main/kotlin/app/k9mail/core/ui/compose/testing/mvi/EventStateTestUtil.kt
new file mode 100644
index 0000000000000000000000000000000000000000..2895ed3acdbbaedf93ce6e599e2c98e8d9b894f2
--- /dev/null
+++ b/core/ui/compose/testing/src/main/kotlin/app/k9mail/core/ui/compose/testing/mvi/EventStateTestUtil.kt
@@ -0,0 +1,35 @@
+package app.k9mail.core.ui.compose.testing.mvi
+
+import app.cash.turbine.testIn
+import app.k9mail.core.ui.compose.common.mvi.UnidirectionalViewModel
+import assertk.assertions.assertThatAndTurbinesConsumed
+import assertk.assertions.isEqualTo
+import kotlinx.coroutines.CoroutineScope
+
+suspend fun <STATE, EVENT, EFFECT> eventStateTest(
+    viewModel: UnidirectionalViewModel<STATE, EVENT, EFFECT>,
+    initialState: STATE,
+    event: EVENT,
+    expectedState: STATE,
+    coroutineScope: CoroutineScope,
+) {
+    val stateTurbine = viewModel.state.testIn(coroutineScope)
+    val effectTurbine = viewModel.effect.testIn(coroutineScope)
+    val turbines = listOf(stateTurbine, effectTurbine)
+
+    assertThatAndTurbinesConsumed(
+        actual = stateTurbine.awaitItem(),
+        turbines = turbines,
+    ) {
+        isEqualTo(initialState)
+    }
+
+    viewModel.event(event)
+
+    assertThatAndTurbinesConsumed(
+        actual = stateTurbine.awaitItem(),
+        turbines = turbines,
+    ) {
+        isEqualTo(expectedState)
+    }
+}
diff --git a/core/ui/compose/testing/src/main/kotlin/app/k9mail/core/ui/compose/testing/mvi/MviTurbineExtension.kt b/core/ui/compose/testing/src/main/kotlin/app/k9mail/core/ui/compose/testing/mvi/MviTurbineExtension.kt
new file mode 100644
index 0000000000000000000000000000000000000000..23e77d1bccbc73d1d6f1015c3f77699fca1fb2cc
--- /dev/null
+++ b/core/ui/compose/testing/src/main/kotlin/app/k9mail/core/ui/compose/testing/mvi/MviTurbineExtension.kt
@@ -0,0 +1,85 @@
+package app.k9mail.core.ui.compose.testing.mvi
+
+import app.cash.turbine.ReceiveTurbine
+import app.cash.turbine.testIn
+import app.k9mail.core.ui.compose.common.mvi.UnidirectionalViewModel
+import assertk.Assert
+import assertk.all
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import kotlinx.coroutines.test.TestScope
+
+/**
+ * The `turbines` extension function creates a MviTurbines instance for the given MVI ViewModel.
+ */
+inline fun <reified STATE, EVENT, EFFECT> TestScope.turbines(
+    viewModel: UnidirectionalViewModel<STATE, EVENT, EFFECT>,
+): MviTurbines<STATE, EFFECT> {
+    return MviTurbines(
+        stateTurbine = viewModel.state.testIn(backgroundScope),
+        effectTurbine = viewModel.effect.testIn(backgroundScope),
+    )
+}
+
+/**
+ * The `turbinesWithInitialStateCheck` extension function creates a MviTurbines instance for the given MVI ViewModel
+ * and ensures that the initial state is emitted.
+ */
+suspend inline fun <reified STATE, EVENT, EFFECT> TestScope.turbinesWithInitialStateCheck(
+    viewModel: UnidirectionalViewModel<STATE, EVENT, EFFECT>,
+    initialState: STATE,
+): MviTurbines<STATE, EFFECT> {
+    val turbines = turbines(viewModel)
+
+    assertThatAndMviTurbinesConsumed(
+        actual = turbines.stateTurbine.awaitItem(),
+        turbines = turbines,
+    ) {
+        isEqualTo(initialState)
+    }
+
+    return turbines
+}
+
+/**
+ * The `assertThatAndMviTurbinesConsumed` function ensures that the assertion passed and
+ * all events in the given MviTurbines have been consumed.
+ *
+ * Usage:
+ *  val actualValue: T = getActualValue()
+ *  val turbines = viewModel.turbines(coroutineScope)
+ *  assertThatAndMviTurbinesConsumed(actualValue, turbines) {
+ *     // your assertion here
+ *  }
+ *
+ *  @param T The type of the actual value.
+ *  @param STATE The type of the state.
+ *  @param EFFECT The type of the effect.
+ *  @param actual The actual value being asserted.
+ *  @param turbines The MviTurbines instance to check if all events are consumed.
+ *  @param assertion An extension function on `Assert<T>`, which is used to define assertions on the actual value.
+ */
+fun <T, STATE, EFFECT> assertThatAndMviTurbinesConsumed(
+    actual: T,
+    turbines: MviTurbines<STATE, EFFECT>,
+    assertion: Assert<T>.() -> Unit,
+) {
+    assertThat(actual).all {
+        assertion()
+    }
+
+    turbines.stateTurbine.ensureAllEventsConsumed()
+    turbines.effectTurbine.ensureAllEventsConsumed()
+}
+
+/**
+ * A container class for the state and effect turbines of an MVI ViewModel.
+ */
+data class MviTurbines<STATE, EFFECT>(
+    val stateTurbine: ReceiveTurbine<STATE>,
+    val effectTurbine: ReceiveTurbine<EFFECT>,
+) {
+    suspend fun awaitStateItem() = stateTurbine.awaitItem()
+
+    suspend fun awaitEffectItem() = effectTurbine.awaitItem()
+}
diff --git a/core/ui/compose/theme/build.gradle.kts b/core/ui/compose/theme/build.gradle.kts
index 08dae1d6cb4acf6e7c5dbbb5a5dd442845438079..30b8ecc1ae6ecab856b32c170b4a1fd9d497f22e 100644
--- a/core/ui/compose/theme/build.gradle.kts
+++ b/core/ui/compose/theme/build.gradle.kts
@@ -11,4 +11,5 @@ dependencies {
     api(projects.core.ui.compose.common)
     implementation(libs.accompanist.systemuicontroller)
     implementation(libs.androidx.compose.material)
+    implementation(libs.androidx.compose.material.icons.extended)
 }
diff --git a/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/Icons.kt b/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/Icons.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d53125475fa1247d13ece1c2954f26f44b144006
--- /dev/null
+++ b/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/Icons.kt
@@ -0,0 +1,52 @@
+package app.k9mail.core.ui.compose.theme
+
+import androidx.compose.material.icons.filled.AccountCircle
+import androidx.compose.material.icons.filled.Check
+import androidx.compose.material.icons.filled.Error
+import androidx.compose.material.icons.filled.Menu
+import androidx.compose.material.icons.filled.MoveToInbox
+import androidx.compose.material.icons.filled.Notifications
+import androidx.compose.material.icons.filled.Outbox
+import androidx.compose.material.icons.filled.Security
+import androidx.compose.material.icons.filled.Visibility
+import androidx.compose.material.icons.filled.VisibilityOff
+import androidx.compose.material.icons.outlined.ArrowBack
+import androidx.compose.material.icons.outlined.ArrowDropDown
+import androidx.compose.material.icons.outlined.ArrowDropUp
+import androidx.compose.material.icons.outlined.Celebration
+import androidx.compose.material.icons.outlined.Check
+import androidx.compose.material.icons.outlined.Error
+import androidx.compose.material.icons.outlined.ErrorOutline
+import androidx.compose.material.icons.outlined.ExpandLess
+import androidx.compose.material.icons.outlined.ExpandMore
+import androidx.compose.material.icons.outlined.Info
+import androidx.compose.material.icons.outlined.Menu
+import androidx.compose.material.icons.outlined.WarningAmber
+import androidx.compose.material.icons.Icons as MaterialIcons
+
+object Icons {
+    object Filled {
+        val error = MaterialIcons.Filled.Error
+        val inbox = MaterialIcons.Filled.MoveToInbox
+        val notification = MaterialIcons.Filled.Notifications
+        val outbox = MaterialIcons.Filled.Outbox
+        val security = MaterialIcons.Filled.Security
+        val passwordVisibility = MaterialIcons.Filled.Visibility
+        val passwordVisibilityOff = MaterialIcons.Filled.VisibilityOff
+        val user = MaterialIcons.Filled.AccountCircle
+    }
+
+    object Outlined {
+        val arrowBack = MaterialIcons.Outlined.ArrowBack
+        val arrowDropDown = MaterialIcons.Outlined.ArrowDropDown
+        val arrowDropUp = MaterialIcons.Outlined.ArrowDropUp
+        val celebration = MaterialIcons.Outlined.Celebration
+        val menu = MaterialIcons.Outlined.Menu
+        val check = MaterialIcons.Outlined.Check
+        val info = MaterialIcons.Outlined.Info
+        val warning = MaterialIcons.Outlined.WarningAmber
+        val error = MaterialIcons.Outlined.ErrorOutline
+        val expandMore = MaterialIcons.Outlined.ExpandMore
+        val expandLess = MaterialIcons.Outlined.ExpandLess
+    }
+}
diff --git a/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/MainTheme.kt b/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/MainTheme.kt
index 2d48f928545319d1fc9854aa8cd3b1977d015ba3..daf78a40edda43351d0b8ec4dce8e02cb1e0ced0 100644
--- a/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/MainTheme.kt
+++ b/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/MainTheme.kt
@@ -2,7 +2,6 @@ package app.k9mail.core.ui.compose.theme
 
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.material.MaterialTheme
-import androidx.compose.material.Shapes
 import androidx.compose.material.Typography
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
@@ -34,17 +33,20 @@ fun MainTheme(
 
     SetSystemBarsColor(color = colors.toolbar)
 
+    val shapes = MainTheme.shapes
+
     CompositionLocalProvider(
         LocalColors provides colors,
         LocalElevations provides Elevations(),
         LocalImages provides images,
         LocalSizes provides Sizes(),
         LocalSpacings provides Spacings(),
+        LocalShapes provides shapes,
     ) {
         MaterialTheme(
             colors = colors.toMaterialColors(),
             typography = typography,
-            shapes = shapes,
+            shapes = shapes.toMaterialShapes(),
             content = content,
         )
     }
@@ -64,7 +66,7 @@ object MainTheme {
     val shapes: Shapes
         @Composable
         @ReadOnlyComposable
-        get() = MaterialTheme.shapes
+        get() = LocalShapes.current
 
     val spacings: Spacings
         @Composable
diff --git a/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/Shapes.kt b/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/Shapes.kt
index 722200dfc92568a05dd0a232cae52cc24137d7c5..6ff96291a9d5251e8d99f2a66def8f8f7148e115 100644
--- a/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/Shapes.kt
+++ b/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/Shapes.kt
@@ -1,11 +1,23 @@
 package app.k9mail.core.ui.compose.theme
 
+import androidx.compose.foundation.shape.CornerBasedShape
 import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material.Shapes
+import androidx.compose.runtime.Immutable
+import androidx.compose.runtime.staticCompositionLocalOf
 import androidx.compose.ui.unit.dp
+import androidx.compose.material.Shapes as MaterialShapes
 
-val shapes = Shapes(
-    small = RoundedCornerShape(8.dp),
-    medium = RoundedCornerShape(4.dp),
-    large = RoundedCornerShape(0.dp),
+@Immutable
+data class Shapes(
+    val small: CornerBasedShape = RoundedCornerShape(8.dp),
+    val medium: CornerBasedShape = RoundedCornerShape(4.dp),
+    val large: CornerBasedShape = RoundedCornerShape(0.dp),
 )
+
+internal fun Shapes.toMaterialShapes() = MaterialShapes(
+    small = small,
+    medium = medium,
+    large = large,
+)
+
+internal val LocalShapes = staticCompositionLocalOf { Shapes() }
diff --git a/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/Sizes.kt b/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/Sizes.kt
index 8053c6f00ee92d6940d9fb0aacde06e106c8abf5..148270cf7b2871fe12f3ab6e81fab76c9a60b054 100644
--- a/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/Sizes.kt
+++ b/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/Sizes.kt
@@ -14,6 +14,11 @@ data class Sizes(
     val larger: Dp = 128.dp,
     val huge: Dp = 256.dp,
     val huger: Dp = 384.dp,
+
+    val icon: Dp = 24.dp,
+
+    val topBarHeight: Dp = 56.dp,
+    val bottomBarHeight: Dp = 56.dp,
 )
 
 internal val LocalSizes = staticCompositionLocalOf { Sizes() }
diff --git a/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/Spacings.kt b/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/Spacings.kt
index 5691998d36c3cda591cbac05c922ae7a5bca6f56..8db26b1b95b251cfd4f671327f5f0db152f6a70c 100644
--- a/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/Spacings.kt
+++ b/core/ui/compose/theme/src/main/java/app/k9mail/core/ui/compose/theme/Spacings.kt
@@ -7,6 +7,8 @@ import androidx.compose.ui.unit.dp
 
 @Immutable
 data class Spacings(
+    val zero: Dp = 0.dp,
+
     val quarter: Dp = 2.dp,
     val half: Dp = 4.dp,
     val default: Dp = 8.dp,
diff --git a/fastlane/metadata/android/en-US/changelogs/36002.txt b/fastlane/metadata/android/en-US/changelogs/36002.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b38624fb1ede331b83c7936816d6dcc76a746cf2
--- /dev/null
+++ b/fastlane/metadata/android/en-US/changelogs/36002.txt
@@ -0,0 +1 @@
+- Change primary action in message view header from "reply all" to "reply"
diff --git a/fastlane/metadata/android/en-US/changelogs/37004.txt b/fastlane/metadata/android/en-US/changelogs/37004.txt
new file mode 100644
index 0000000000000000000000000000000000000000..60b807daea1661d361b40d2de3d8fc68f2d90948
--- /dev/null
+++ b/fastlane/metadata/android/en-US/changelogs/37004.txt
@@ -0,0 +1,4 @@
+- Changed primary action in message view header from "reply all" to "reply"
+- Fixed the app so it runs on devices that don't support home screen widgets
+- Fixed bug where "Cannot connect to crypto provider" was displayed when the problem wasn't the crypto provider
+- Updated translations
diff --git a/fastlane/metadata/android/en-US/changelogs/37005.txt b/fastlane/metadata/android/en-US/changelogs/37005.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a20be7dbc65f4330a5ec990230c34b8e312e0fcd
--- /dev/null
+++ b/fastlane/metadata/android/en-US/changelogs/37005.txt
@@ -0,0 +1,7 @@
+- Adding to contacts should now allow you again to add the email address to an existing contact
+- Fixed display issue with recipients in message view screen
+- Fixed appearance of "Sign in with Google" button
+- Fixed bugs with importing and exporting identities
+- Manually entering names containing non-latin characters is now possible when composing messages
+- The app will no longer ask to save a draft when no changes have been made to an existing draft message
+- Updated translations
diff --git a/fastlane/metadata/android/en-US/changelogs/37006.txt b/fastlane/metadata/android/en-US/changelogs/37006.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3ec017936ff8fc31bc890c4a4979968385edf2a7
--- /dev/null
+++ b/fastlane/metadata/android/en-US/changelogs/37006.txt
@@ -0,0 +1,2 @@
+- Fixed a bug that lead to folders appearing to be empty
+- Don't use nickname as display name when auto-completing recipient using the nickname
diff --git a/fastlane/metadata/android/en-US/changelogs/37007.txt b/fastlane/metadata/android/en-US/changelogs/37007.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7c115cf14087e9d2f14547c6c05c8b582de4a5e9
--- /dev/null
+++ b/fastlane/metadata/android/en-US/changelogs/37007.txt
@@ -0,0 +1 @@
+- Fixed bug where navigating to a different screen after using the system back button/gesture could crash the app
diff --git a/fastlane/metadata/android/en-US/changelogs/37008.txt b/fastlane/metadata/android/en-US/changelogs/37008.txt
new file mode 100644
index 0000000000000000000000000000000000000000..221d25025cd6b3c3621d6870ee7ac1dd7d058724
--- /dev/null
+++ b/fastlane/metadata/android/en-US/changelogs/37008.txt
@@ -0,0 +1,10 @@
+- Changed compose icon in the message list widget to match the icon inside the app
+- Added information about the read state of a message to the data read by screen readers
+- A URI pasted when composing a message will now be surrounded by angle brackets
+- Improved error handling in many situations
+- Fixed bug where account name wasn't displayed in the message view when it should
+- Fixed inconsistent behavior when replying to messages
+- Fixed bug when saving a draft message using an identity without a display name
+- Fixed display issue when removing an account
+- Quite a few internal changes
+- Updated translations
diff --git a/fastlane/metadata/android/en-US/changelogs/37009.txt b/fastlane/metadata/android/en-US/changelogs/37009.txt
new file mode 100644
index 0000000000000000000000000000000000000000..dff77c8f56b92c2d08b594edc1f4112b6c3c6996
--- /dev/null
+++ b/fastlane/metadata/android/en-US/changelogs/37009.txt
@@ -0,0 +1 @@
+- Enabled the new and improved account setup flow
diff --git a/fastlane/metadata/android/en-US/changelogs/37010.txt b/fastlane/metadata/android/en-US/changelogs/37010.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3a7228f4926fb48e91acdb951c3cf62b4e243db7
--- /dev/null
+++ b/fastlane/metadata/android/en-US/changelogs/37010.txt
@@ -0,0 +1,2 @@
+- Fixed bug where accounts using OAuth weren't set up properly in K-9 Mail 6.709
+- Moved "Show only subscribed folders" setting to "Folders" section
diff --git a/fastlane/metadata/android/en-US/images/phoneScreenshots/1.png b/fastlane/metadata/android/en-US/images/phoneScreenshots/1.png
index 1fd78aba1fad850f12513dc8a0d2d46ecaa846cb..6ff66dd4d2f5781d28941bb94b0d44e5236ca650 100644
Binary files a/fastlane/metadata/android/en-US/images/phoneScreenshots/1.png and b/fastlane/metadata/android/en-US/images/phoneScreenshots/1.png differ
diff --git a/fastlane/metadata/android/en-US/images/phoneScreenshots/2.png b/fastlane/metadata/android/en-US/images/phoneScreenshots/2.png
index 0c2dbfb6374768f945e2f99768c5c40175350b64..9e13396bdd982fe3565ce70f7dfd0a364ba45265 100644
Binary files a/fastlane/metadata/android/en-US/images/phoneScreenshots/2.png and b/fastlane/metadata/android/en-US/images/phoneScreenshots/2.png differ
diff --git a/fastlane/metadata/android/en-US/images/phoneScreenshots/3.png b/fastlane/metadata/android/en-US/images/phoneScreenshots/3.png
index 2a04a9f21800ad20883dae05d770793fd6050999..0feca6c286fd968db461dce07e4ab622612691b6 100644
Binary files a/fastlane/metadata/android/en-US/images/phoneScreenshots/3.png and b/fastlane/metadata/android/en-US/images/phoneScreenshots/3.png differ
diff --git a/fastlane/metadata/android/en-US/images/phoneScreenshots/4.png b/fastlane/metadata/android/en-US/images/phoneScreenshots/4.png
index d9388175cb5cb3729c202e786ecbc1bf4fb11db7..c4088f9c38504422a2c7dce33e44ad1eabda1975 100644
Binary files a/fastlane/metadata/android/en-US/images/phoneScreenshots/4.png and b/fastlane/metadata/android/en-US/images/phoneScreenshots/4.png differ
diff --git a/fastlane/metadata/android/en-US/images/phoneScreenshots/5.png b/fastlane/metadata/android/en-US/images/phoneScreenshots/5.png
index b10056b5144414c310044f1c5dd9502076278863..233190fbeae977c15adbf60e66ca65dd7b263510 100644
Binary files a/fastlane/metadata/android/en-US/images/phoneScreenshots/5.png and b/fastlane/metadata/android/en-US/images/phoneScreenshots/5.png differ
diff --git a/fastlane/metadata/android/en-US/images/sevenInchScreenshots/1.png b/fastlane/metadata/android/en-US/images/sevenInchScreenshots/1.png
index 05aa907f8c63b2d13528330b9ab23325bd62163f..631c557418a013acc1f529f13a02c0a4ce80a991 100644
Binary files a/fastlane/metadata/android/en-US/images/sevenInchScreenshots/1.png and b/fastlane/metadata/android/en-US/images/sevenInchScreenshots/1.png differ
diff --git a/fastlane/metadata/android/en-US/images/tenInchScreenshots/1.png b/fastlane/metadata/android/en-US/images/tenInchScreenshots/1.png
index f0ddcb7b601a0616af7684ef2140ccd08b520e4f..ad32cab3f3a68de1700ef516f5e4a376615e12a8 100644
Binary files a/fastlane/metadata/android/en-US/images/tenInchScreenshots/1.png and b/fastlane/metadata/android/en-US/images/tenInchScreenshots/1.png differ
diff --git a/feature/account/common/build.gradle.kts b/feature/account/common/build.gradle.kts
new file mode 100644
index 0000000000000000000000000000000000000000..743c8e4e00c2e7e6e299fd3c8b8fed06426ce224
--- /dev/null
+++ b/feature/account/common/build.gradle.kts
@@ -0,0 +1,15 @@
+plugins {
+    id(ThunderbirdPlugins.Library.androidCompose)
+}
+
+android {
+    namespace = "app.k9mail.feature.account.common"
+    resourcePrefix = "account_common_"
+}
+
+dependencies {
+    implementation(projects.core.ui.compose.designsystem)
+    implementation(projects.core.common)
+
+    testImplementation(projects.core.ui.compose.testing)
+}
diff --git a/feature/account/common/src/main/kotlin/app/k9mail/feature/account/common/ui/AppTitleTopHeader.kt b/feature/account/common/src/main/kotlin/app/k9mail/feature/account/common/ui/AppTitleTopHeader.kt
new file mode 100644
index 0000000000000000000000000000000000000000..13fde1bf9d339833ebb9804a00e8ebd204523f2a
--- /dev/null
+++ b/feature/account/common/src/main/kotlin/app/k9mail/feature/account/common/ui/AppTitleTopHeader.kt
@@ -0,0 +1,69 @@
+package app.k9mail.feature.account.common.ui
+
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.withStyle
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline2
+import app.k9mail.core.ui.compose.designsystem.template.ResponsiveWidthContainer
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+
+@Composable
+fun AppTitleTopHeader(
+    title: String,
+    modifier: Modifier = Modifier,
+) {
+    ResponsiveWidthContainer(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(
+                top = MainTheme.spacings.quadruple,
+                bottom = MainTheme.spacings.default,
+            )
+            .then(modifier),
+    ) {
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(
+                    start = MainTheme.spacings.half,
+                    end = MainTheme.spacings.quadruple,
+                )
+                .then(modifier),
+            horizontalArrangement = Arrangement.Center,
+            verticalAlignment = Alignment.CenterVertically,
+        ) {
+            Image(
+                painter = painterResource(id = MainTheme.images.logo),
+                contentDescription = null,
+            )
+
+            TextHeadline2(
+                text = buildAnnotatedString {
+                    withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+                        append(title)
+                    }
+                },
+            )
+        }
+    }
+}
+
+@Preview
+@Composable
+internal fun AppTitleTopHeaderPreview() {
+    PreviewWithThemes {
+        AppTitleTopHeader("Title")
+    }
+}
diff --git a/feature/account/common/src/main/kotlin/app/k9mail/feature/account/common/ui/ContentListView.kt b/feature/account/common/src/main/kotlin/app/k9mail/feature/account/common/ui/ContentListView.kt
new file mode 100644
index 0000000000000000000000000000000000000000..64c92dbe533a3968afc3c28fe411ff6bde2326e8
--- /dev/null
+++ b/feature/account/common/src/main/kotlin/app/k9mail/feature/account/common/ui/ContentListView.kt
@@ -0,0 +1,62 @@
+package app.k9mail.feature.account.common.ui
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.imePadding
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.LazyListScope
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextSubtitle1
+import app.k9mail.core.ui.compose.designsystem.template.ResponsiveWidthContainer
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+
+@Composable
+fun ContentListView(
+    modifier: Modifier = Modifier,
+    contentPadding: PaddingValues = PaddingValues(),
+    horizontalAlignment: Alignment.Horizontal = Alignment.Start,
+    verticalArrangement: Arrangement.Vertical = Arrangement.spacedBy(MainTheme.spacings.default),
+    items: LazyListScope.() -> Unit,
+) {
+    ResponsiveWidthContainer(
+        modifier = Modifier
+            .padding(contentPadding)
+            .fillMaxWidth()
+            .then(modifier),
+    ) {
+        LazyColumn(
+            modifier = Modifier
+                .fillMaxSize()
+                .imePadding(),
+            horizontalAlignment = horizontalAlignment,
+            verticalArrangement = verticalArrangement,
+        ) {
+            items()
+        }
+    }
+}
+
+@Preview
+@Composable
+internal fun ContentListViewPreview() {
+    PreviewWithThemes {
+        ContentListView {
+            item {
+                TextSubtitle1("Item 1")
+            }
+            item {
+                TextSubtitle1("Item 2")
+            }
+            item {
+                TextSubtitle1("Item 3")
+            }
+        }
+    }
+}
diff --git a/feature/account/common/src/main/kotlin/app/k9mail/feature/account/common/ui/WizardNavigationBar.kt b/feature/account/common/src/main/kotlin/app/k9mail/feature/account/common/ui/WizardNavigationBar.kt
new file mode 100644
index 0000000000000000000000000000000000000000..f2e625d254f122245919772699df8476561b5d9a
--- /dev/null
+++ b/feature/account/common/src/main/kotlin/app/k9mail/feature/account/common/ui/WizardNavigationBar.kt
@@ -0,0 +1,143 @@
+package app.k9mail.feature.account.common.ui
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import app.k9mail.core.ui.compose.common.DevicePreviews
+import app.k9mail.core.ui.compose.designsystem.atom.button.Button
+import app.k9mail.core.ui.compose.designsystem.atom.button.ButtonOutlined
+import app.k9mail.core.ui.compose.designsystem.template.ResponsiveWidthContainer
+import app.k9mail.core.ui.compose.theme.K9Theme
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+
+@Composable
+fun WizardNavigationBar(
+    nextButtonText: String,
+    backButtonText: String,
+    onNextClick: () -> Unit,
+    onBackClick: () -> Unit,
+    modifier: Modifier = Modifier,
+    state: WizardNavigationBarState = WizardNavigationBarState(),
+) {
+    ResponsiveWidthContainer(
+        modifier = Modifier
+            .fillMaxWidth()
+            .then(modifier),
+    ) {
+        Row(
+            modifier = Modifier
+                .padding(
+                    start = MainTheme.spacings.quadruple,
+                    top = MainTheme.spacings.default,
+                    end = MainTheme.spacings.quadruple,
+                    bottom = MainTheme.spacings.double,
+                )
+                .fillMaxWidth(),
+            horizontalArrangement = getHorizontalArrangement(state),
+        ) {
+            if (state.showBack) {
+                ButtonOutlined(
+                    text = backButtonText,
+                    onClick = onBackClick,
+                    enabled = state.isBackEnabled,
+                )
+            }
+            if (state.showNext) {
+                Button(
+                    text = nextButtonText,
+                    onClick = onNextClick,
+                    enabled = state.isNextEnabled,
+                )
+            }
+        }
+    }
+}
+
+private fun getHorizontalArrangement(state: WizardNavigationBarState): Arrangement.Horizontal {
+    return if (state.showNext && state.showBack) {
+        Arrangement.SpaceBetween
+    } else if (state.showNext) {
+        Arrangement.End
+    } else {
+        Arrangement.Start
+    }
+}
+
+@DevicePreviews
+@Composable
+internal fun WizardNavigationBarK9Preview() {
+    K9Theme {
+        WizardNavigationBar(
+            nextButtonText = "Next",
+            backButtonText = "Back",
+            onNextClick = {},
+            onBackClick = {},
+        )
+    }
+}
+
+@DevicePreviews
+@Composable
+internal fun WizardNavigationBarPreview() {
+    PreviewWithThemes {
+        WizardNavigationBar(
+            nextButtonText = "Next",
+            backButtonText = "Back",
+            onNextClick = {},
+            onBackClick = {},
+        )
+    }
+}
+
+@DevicePreviews
+@Composable
+internal fun WizardNavigationBarDisabledPreview() {
+    PreviewWithThemes {
+        WizardNavigationBar(
+            nextButtonText = "Next",
+            backButtonText = "Back",
+            onNextClick = {},
+            onBackClick = {},
+            state = WizardNavigationBarState(
+                isNextEnabled = false,
+                isBackEnabled = false,
+            ),
+        )
+    }
+}
+
+@DevicePreviews
+@Composable
+internal fun WizardNavigationBarHideNextPreview() {
+    PreviewWithThemes {
+        WizardNavigationBar(
+            nextButtonText = "Next",
+            backButtonText = "Back",
+            onNextClick = {},
+            onBackClick = {},
+            state = WizardNavigationBarState(
+                showNext = false,
+            ),
+        )
+    }
+}
+
+@DevicePreviews
+@Composable
+internal fun WizardNavigationBarHideBackPreview() {
+    PreviewWithThemes {
+        WizardNavigationBar(
+            nextButtonText = "Next",
+            backButtonText = "Back",
+            onNextClick = {},
+            onBackClick = {},
+            state = WizardNavigationBarState(
+                showBack = false,
+            ),
+        )
+    }
+}
diff --git a/feature/account/common/src/main/kotlin/app/k9mail/feature/account/common/ui/WizardNavigationBarState.kt b/feature/account/common/src/main/kotlin/app/k9mail/feature/account/common/ui/WizardNavigationBarState.kt
new file mode 100644
index 0000000000000000000000000000000000000000..276a123b84df4e1d3a3c5c14aff55b36ded97f00
--- /dev/null
+++ b/feature/account/common/src/main/kotlin/app/k9mail/feature/account/common/ui/WizardNavigationBarState.kt
@@ -0,0 +1,8 @@
+package app.k9mail.feature.account.common.ui
+
+data class WizardNavigationBarState(
+    val isNextEnabled: Boolean = true,
+    val showNext: Boolean = true,
+    val isBackEnabled: Boolean = true,
+    val showBack: Boolean = true,
+)
diff --git a/feature/account/common/src/main/kotlin/app/k9mail/feature/account/common/ui/item/ErrorItem.kt b/feature/account/common/src/main/kotlin/app/k9mail/feature/account/common/ui/item/ErrorItem.kt
new file mode 100644
index 0000000000000000000000000000000000000000..128f6a8ba63486679c29bc918ee26d2c6cf34f3b
--- /dev/null
+++ b/feature/account/common/src/main/kotlin/app/k9mail/feature/account/common/ui/item/ErrorItem.kt
@@ -0,0 +1,24 @@
+package app.k9mail.feature.account.common.ui.item
+
+import androidx.compose.foundation.lazy.LazyItemScope
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import app.k9mail.core.ui.compose.designsystem.molecule.ErrorView
+
+@Composable
+fun LazyItemScope.ErrorItem(
+    title: String,
+    modifier: Modifier = Modifier,
+    message: String? = null,
+    onRetry: () -> Unit = { },
+) {
+    ListItem(
+        modifier = modifier,
+    ) {
+        ErrorView(
+            title = title,
+            message = message,
+            onRetry = onRetry,
+        )
+    }
+}
diff --git a/feature/account/common/src/main/kotlin/app/k9mail/feature/account/common/ui/item/ItemPadding.kt b/feature/account/common/src/main/kotlin/app/k9mail/feature/account/common/ui/item/ItemPadding.kt
new file mode 100644
index 0000000000000000000000000000000000000000..27b309736cfe0881ad7076a4556e770bdcc627ef
--- /dev/null
+++ b/feature/account/common/src/main/kotlin/app/k9mail/feature/account/common/ui/item/ItemPadding.kt
@@ -0,0 +1,19 @@
+package app.k9mail.feature.account.common.ui.item
+
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.runtime.Composable
+import app.k9mail.core.ui.compose.theme.MainTheme
+
+@Composable
+fun defaultHeadlineItemPadding() = PaddingValues(
+    start = MainTheme.spacings.quadruple,
+    top = MainTheme.spacings.triple,
+    end = MainTheme.spacings.quadruple,
+    bottom = MainTheme.spacings.default,
+)
+
+@Composable
+fun defaultItemPadding() = PaddingValues(
+    horizontal = MainTheme.spacings.quadruple,
+    vertical = MainTheme.spacings.zero,
+)
diff --git a/feature/account/common/src/main/kotlin/app/k9mail/feature/account/common/ui/item/ListItem.kt b/feature/account/common/src/main/kotlin/app/k9mail/feature/account/common/ui/item/ListItem.kt
new file mode 100644
index 0000000000000000000000000000000000000000..6335209729599508797af250e22292e1e8829fa0
--- /dev/null
+++ b/feature/account/common/src/main/kotlin/app/k9mail/feature/account/common/ui/item/ListItem.kt
@@ -0,0 +1,28 @@
+package app.k9mail.feature.account.common.ui.item
+
+import androidx.compose.foundation.ExperimentalFoundationApi
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyItemScope
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+
+@OptIn(ExperimentalFoundationApi::class)
+@Composable
+fun LazyItemScope.ListItem(
+    modifier: Modifier = Modifier,
+    contentPaddingValues: PaddingValues = defaultItemPadding(),
+    content: @Composable () -> Unit,
+) {
+    Box(
+        modifier = Modifier
+            .padding(contentPaddingValues)
+            .animateItemPlacement()
+            .fillMaxWidth()
+            .then(modifier),
+    ) {
+        content()
+    }
+}
diff --git a/feature/account/common/src/main/kotlin/app/k9mail/feature/account/common/ui/item/LoadingItem.kt b/feature/account/common/src/main/kotlin/app/k9mail/feature/account/common/ui/item/LoadingItem.kt
new file mode 100644
index 0000000000000000000000000000000000000000..9dfa839d9aa878c4d3f3b25ee0735da7ec88067b
--- /dev/null
+++ b/feature/account/common/src/main/kotlin/app/k9mail/feature/account/common/ui/item/LoadingItem.kt
@@ -0,0 +1,20 @@
+package app.k9mail.feature.account.common.ui.item
+
+import androidx.compose.foundation.lazy.LazyItemScope
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import app.k9mail.core.ui.compose.designsystem.molecule.LoadingView
+
+@Composable
+fun LazyItemScope.LoadingItem(
+    modifier: Modifier = Modifier,
+    message: String? = null,
+) {
+    ListItem(
+        modifier = modifier,
+    ) {
+        LoadingView(
+            message = message,
+        )
+    }
+}
diff --git a/feature/account/common/src/main/kotlin/app/k9mail/feature/account/common/ui/item/SuccessItem.kt b/feature/account/common/src/main/kotlin/app/k9mail/feature/account/common/ui/item/SuccessItem.kt
new file mode 100644
index 0000000000000000000000000000000000000000..bba929608169e2a697e56d73de740f62b462196b
--- /dev/null
+++ b/feature/account/common/src/main/kotlin/app/k9mail/feature/account/common/ui/item/SuccessItem.kt
@@ -0,0 +1,20 @@
+package app.k9mail.feature.account.common.ui.item
+
+import androidx.compose.foundation.lazy.LazyItemScope
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import app.k9mail.feature.account.common.ui.view.SuccessView
+
+@Composable
+fun LazyItemScope.SuccessItem(
+    message: String,
+    modifier: Modifier = Modifier,
+) {
+    ListItem(
+        modifier = modifier,
+    ) {
+        SuccessView(
+            message = message,
+        )
+    }
+}
diff --git a/feature/account/common/src/main/kotlin/app/k9mail/feature/account/common/ui/view/SuccessView.kt b/feature/account/common/src/main/kotlin/app/k9mail/feature/account/common/ui/view/SuccessView.kt
new file mode 100644
index 0000000000000000000000000000000000000000..4f8227441236a86312e3ab0396266591ba875840
--- /dev/null
+++ b/feature/account/common/src/main/kotlin/app/k9mail/feature/account/common/ui/view/SuccessView.kt
@@ -0,0 +1,53 @@
+package app.k9mail.feature.account.common.ui.view
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.requiredSize
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.designsystem.atom.Icon
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextSubtitle1
+import app.k9mail.core.ui.compose.theme.Icons
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+
+@Composable
+internal fun SuccessView(
+    message: String,
+    modifier: Modifier = Modifier,
+) {
+    Column(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(MainTheme.spacings.default)
+            .then(modifier),
+        horizontalAlignment = Alignment.CenterHorizontally,
+    ) {
+        TextSubtitle1(text = message)
+        Row(
+            modifier = Modifier.height(MainTheme.sizes.larger),
+            verticalAlignment = Alignment.CenterVertically,
+        ) {
+            Icon(
+                imageVector = Icons.Outlined.celebration,
+                tint = MainTheme.colors.secondary,
+                modifier = Modifier.requiredSize(MainTheme.sizes.large),
+            )
+        }
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun SuccessViewPreview() {
+    PreviewWithThemes {
+        SuccessView(
+            message = "Success",
+        )
+    }
+}
diff --git a/feature/account/oauth/build.gradle.kts b/feature/account/oauth/build.gradle.kts
new file mode 100644
index 0000000000000000000000000000000000000000..4b73b20bb40ad27098d08deebeb8d62c1ce4c3d7
--- /dev/null
+++ b/feature/account/oauth/build.gradle.kts
@@ -0,0 +1,30 @@
+plugins {
+    id(ThunderbirdPlugins.Library.androidCompose)
+}
+
+android {
+    namespace = "app.k9mail.feature.account.oauth"
+    resourcePrefix = "account_oauth_"
+
+    buildTypes {
+        debug {
+            manifestPlaceholders["appAuthRedirectScheme"] = "FIXME: override this in your app project"
+        }
+        release {
+            manifestPlaceholders["appAuthRedirectScheme"] = "FIXME: override this in your app project"
+        }
+    }
+}
+
+dependencies {
+    implementation(projects.core.ui.compose.designsystem)
+    implementation(projects.core.common)
+    implementation(projects.mail.common)
+    implementation(projects.feature.account.common)
+
+    implementation(libs.appauth)
+    implementation(libs.androidx.compose.material)
+    implementation(libs.timber)
+
+    testImplementation(projects.core.ui.compose.testing)
+}
diff --git a/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/AccountOAuthModule.kt b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/AccountOAuthModule.kt
new file mode 100644
index 0000000000000000000000000000000000000000..23f1b90792e05190869dbf857f508e4085f8e8cb
--- /dev/null
+++ b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/AccountOAuthModule.kt
@@ -0,0 +1,58 @@
+package app.k9mail.feature.account.oauth
+
+import app.k9mail.core.common.coreCommonModule
+import app.k9mail.feature.account.oauth.data.AuthorizationRepository
+import app.k9mail.feature.account.oauth.data.AuthorizationStateRepository
+import app.k9mail.feature.account.oauth.domain.DomainContract
+import app.k9mail.feature.account.oauth.domain.DomainContract.UseCase
+import app.k9mail.feature.account.oauth.domain.usecase.CheckIsGoogleSignIn
+import app.k9mail.feature.account.oauth.domain.usecase.FinishOAuthSignIn
+import app.k9mail.feature.account.oauth.domain.usecase.GetOAuthRequestIntent
+import app.k9mail.feature.account.oauth.domain.usecase.SuggestServerName
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract
+import app.k9mail.feature.account.oauth.ui.AccountOAuthViewModel
+import net.openid.appauth.AuthorizationService
+import org.koin.android.ext.koin.androidApplication
+import org.koin.core.module.Module
+import org.koin.dsl.module
+
+val featureAccountOAuthModule: Module = module {
+    includes(coreCommonModule)
+
+    factory {
+        AuthorizationService(
+            androidApplication(),
+        )
+    }
+
+    factory<DomainContract.AuthorizationRepository> {
+        AuthorizationRepository(
+            service = get(),
+        )
+    }
+
+    factory<DomainContract.AuthorizationStateRepository> {
+        AuthorizationStateRepository()
+    }
+
+    factory<UseCase.SuggestServerName> { SuggestServerName() }
+
+    factory<UseCase.GetOAuthRequestIntent> {
+        GetOAuthRequestIntent(
+            repository = get(),
+            configurationProvider = get(),
+        )
+    }
+
+    factory<UseCase.FinishOAuthSignIn> { FinishOAuthSignIn(repository = get()) }
+
+    factory<UseCase.CheckIsGoogleSignIn> { CheckIsGoogleSignIn() }
+
+    factory<AccountOAuthContract.ViewModel> {
+        AccountOAuthViewModel(
+            getOAuthRequestIntent = get(),
+            finishOAuthSignIn = get(),
+            checkIsGoogleSignIn = get(),
+        )
+    }
+}
diff --git a/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/data/AuthStateExtension.kt b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/data/AuthStateExtension.kt
new file mode 100644
index 0000000000000000000000000000000000000000..33c9b8c37c05e7346ae2a3a477d1d30ee75d3b6d
--- /dev/null
+++ b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/data/AuthStateExtension.kt
@@ -0,0 +1,24 @@
+package app.k9mail.feature.account.oauth.data
+
+import app.k9mail.feature.account.oauth.domain.entity.AuthorizationState
+import net.openid.appauth.AuthState
+import org.json.JSONException
+import timber.log.Timber
+
+fun AuthState.toAuthorizationState(): AuthorizationState {
+    return try {
+        AuthorizationState(state = jsonSerializeString())
+    } catch (e: JSONException) {
+        Timber.e(e, "Error serializing AuthorizationState")
+        AuthorizationState()
+    }
+}
+
+fun AuthorizationState.toAuthState(): AuthState {
+    return try {
+        state?.let { AuthState.jsonDeserialize(it) } ?: AuthState()
+    } catch (e: JSONException) {
+        Timber.e(e, "Error deserializing AuthorizationState")
+        AuthState()
+    }
+}
diff --git a/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/data/AuthorizationRepository.kt b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/data/AuthorizationRepository.kt
new file mode 100644
index 0000000000000000000000000000000000000000..5617d36c28aa3ded4699a234c4843752daad6378
--- /dev/null
+++ b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/data/AuthorizationRepository.kt
@@ -0,0 +1,91 @@
+package app.k9mail.feature.account.oauth.data
+
+import android.content.Intent
+import androidx.core.net.toUri
+import app.k9mail.core.common.oauth.OAuthConfiguration
+import app.k9mail.feature.account.oauth.domain.DomainContract
+import app.k9mail.feature.account.oauth.domain.entity.AuthorizationIntentResult
+import app.k9mail.feature.account.oauth.domain.entity.AuthorizationResult
+import kotlin.coroutines.resume
+import kotlin.coroutines.suspendCoroutine
+import net.openid.appauth.AuthState
+import net.openid.appauth.AuthorizationException
+import net.openid.appauth.AuthorizationRequest
+import net.openid.appauth.AuthorizationResponse
+import net.openid.appauth.AuthorizationService
+import net.openid.appauth.AuthorizationServiceConfiguration
+import net.openid.appauth.ResponseTypeValues
+import timber.log.Timber
+
+class AuthorizationRepository(
+    private val service: AuthorizationService,
+) : DomainContract.AuthorizationRepository {
+
+    override fun getAuthorizationRequestIntent(
+        configuration: OAuthConfiguration,
+        emailAddress: String,
+    ): AuthorizationIntentResult {
+        return AuthorizationIntentResult.Success(
+            createAuthorizationRequestIntent(configuration, emailAddress),
+        )
+    }
+
+    override suspend fun getAuthorizationResponse(intent: Intent): AuthorizationResponse? {
+        return try {
+            AuthorizationResponse.fromIntent(intent)
+        } catch (e: IllegalArgumentException) {
+            Timber.e(e, "Error deserializing AuthorizationResponse")
+            null
+        }
+    }
+
+    override suspend fun getAuthorizationException(intent: Intent): AuthorizationException? {
+        return try {
+            AuthorizationException.fromIntent(intent)
+        } catch (e: IllegalArgumentException) {
+            Timber.e(e, "Error deserializing AuthorizationException")
+            null
+        }
+    }
+
+    override suspend fun getExchangeToken(
+        response: AuthorizationResponse,
+    ): AuthorizationResult = suspendCoroutine { continuation ->
+        val tokenRequest = response.createTokenExchangeRequest()
+
+        service.performTokenRequest(tokenRequest) { tokenResponse, authorizationException ->
+            val result = if (authorizationException != null) {
+                AuthorizationResult.Failure(authorizationException)
+            } else if (tokenResponse != null) {
+                val authState = AuthState(response, tokenResponse, null)
+                AuthorizationResult.Success(authState.toAuthorizationState())
+            } else {
+                AuthorizationResult.Failure(Exception("Unknown error"))
+            }
+
+            continuation.resume(result)
+        }
+    }
+
+    private fun createAuthorizationRequestIntent(configuration: OAuthConfiguration, emailAddress: String): Intent {
+        val serviceConfig = AuthorizationServiceConfiguration(
+            configuration.authorizationEndpoint.toUri(),
+            configuration.tokenEndpoint.toUri(),
+        )
+
+        val authRequestBuilder = AuthorizationRequest.Builder(
+            serviceConfig,
+            configuration.clientId,
+            ResponseTypeValues.CODE,
+            configuration.redirectUri.toUri(),
+        )
+
+        val authRequest = authRequestBuilder
+            .setScope(configuration.scopes.joinToString(" "))
+            .setCodeVerifier(null)
+            .setLoginHint(emailAddress)
+            .build()
+
+        return service.getAuthorizationRequestIntent(authRequest)
+    }
+}
diff --git a/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/data/AuthorizationStateRepository.kt b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/data/AuthorizationStateRepository.kt
new file mode 100644
index 0000000000000000000000000000000000000000..35ef90cc12b75530d254fc3ba5a11e1bf554d470
--- /dev/null
+++ b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/data/AuthorizationStateRepository.kt
@@ -0,0 +1,12 @@
+package app.k9mail.feature.account.oauth.data
+
+import app.k9mail.feature.account.oauth.domain.DomainContract
+import app.k9mail.feature.account.oauth.domain.entity.AuthorizationState
+
+class AuthorizationStateRepository : DomainContract.AuthorizationStateRepository {
+    override fun isAuthorized(authorizationState: AuthorizationState): Boolean {
+        val authState = authorizationState.toAuthState()
+
+        return authState.isAuthorized
+    }
+}
diff --git a/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/domain/DomainContract.kt b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/domain/DomainContract.kt
new file mode 100644
index 0000000000000000000000000000000000000000..157695b39769f8f62d0962a475be020784c53656
--- /dev/null
+++ b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/domain/DomainContract.kt
@@ -0,0 +1,46 @@
+package app.k9mail.feature.account.oauth.domain
+
+import android.content.Intent
+import app.k9mail.core.common.oauth.OAuthConfiguration
+import app.k9mail.feature.account.oauth.domain.entity.AuthorizationIntentResult
+import app.k9mail.feature.account.oauth.domain.entity.AuthorizationResult
+import app.k9mail.feature.account.oauth.domain.entity.AuthorizationState
+import net.openid.appauth.AuthorizationException
+import net.openid.appauth.AuthorizationResponse
+
+interface DomainContract {
+
+    interface UseCase {
+        fun interface SuggestServerName {
+            fun suggest(protocol: String, domain: String): String
+        }
+
+        fun interface GetOAuthRequestIntent {
+            fun execute(hostname: String, emailAddress: String): AuthorizationIntentResult
+        }
+
+        fun interface FinishOAuthSignIn {
+            suspend fun execute(intent: Intent): AuthorizationResult
+        }
+
+        fun interface CheckIsGoogleSignIn {
+            fun execute(hostname: String): Boolean
+        }
+    }
+
+    interface AuthorizationRepository {
+        fun getAuthorizationRequestIntent(
+            configuration: OAuthConfiguration,
+            emailAddress: String,
+        ): AuthorizationIntentResult
+
+        suspend fun getAuthorizationResponse(intent: Intent): AuthorizationResponse?
+        suspend fun getAuthorizationException(intent: Intent): AuthorizationException?
+
+        suspend fun getExchangeToken(response: AuthorizationResponse): AuthorizationResult
+    }
+
+    fun interface AuthorizationStateRepository {
+        fun isAuthorized(authorizationState: AuthorizationState): Boolean
+    }
+}
diff --git a/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/domain/entity/AuthorizationIntentResult.kt b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/domain/entity/AuthorizationIntentResult.kt
new file mode 100644
index 0000000000000000000000000000000000000000..2abc7379ab3de592d0be6ebac25e2ed6ad8dd9a5
--- /dev/null
+++ b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/domain/entity/AuthorizationIntentResult.kt
@@ -0,0 +1,11 @@
+package app.k9mail.feature.account.oauth.domain.entity
+
+import android.content.Intent
+
+sealed interface AuthorizationIntentResult {
+    object NotSupported : AuthorizationIntentResult
+
+    data class Success(
+        val intent: Intent,
+    ) : AuthorizationIntentResult
+}
diff --git a/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/domain/entity/AuthorizationResult.kt b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/domain/entity/AuthorizationResult.kt
new file mode 100644
index 0000000000000000000000000000000000000000..28cceab189f178412e0d0494b902a23a958ff07e
--- /dev/null
+++ b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/domain/entity/AuthorizationResult.kt
@@ -0,0 +1,16 @@
+package app.k9mail.feature.account.oauth.domain.entity
+
+sealed interface AuthorizationResult {
+
+    data class Success(
+        val state: AuthorizationState,
+    ) : AuthorizationResult
+
+    data class Failure(
+        val error: Exception,
+    ) : AuthorizationResult
+
+    object BrowserNotAvailable : AuthorizationResult
+
+    object Canceled : AuthorizationResult
+}
diff --git a/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/domain/entity/AuthorizationState.kt b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/domain/entity/AuthorizationState.kt
new file mode 100644
index 0000000000000000000000000000000000000000..16fb9e649ffd1b05159fa0d78c2755c891cc2d72
--- /dev/null
+++ b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/domain/entity/AuthorizationState.kt
@@ -0,0 +1,5 @@
+package app.k9mail.feature.account.oauth.domain.entity
+
+data class AuthorizationState(
+    val state: String? = null,
+)
diff --git a/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/domain/entity/OAuthResult.kt b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/domain/entity/OAuthResult.kt
new file mode 100644
index 0000000000000000000000000000000000000000..9bc7407b238d30328415550759c477f66a76340e
--- /dev/null
+++ b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/domain/entity/OAuthResult.kt
@@ -0,0 +1,9 @@
+package app.k9mail.feature.account.oauth.domain.entity
+
+sealed interface OAuthResult {
+    data class Success(
+        val authorizationState: AuthorizationState,
+    ) : OAuthResult
+
+    object Failure : OAuthResult
+}
diff --git a/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/domain/usecase/CheckIsGoogleSignIn.kt b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/domain/usecase/CheckIsGoogleSignIn.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c395e468d67949f3ca4703622ca00903fb55bf7f
--- /dev/null
+++ b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/domain/usecase/CheckIsGoogleSignIn.kt
@@ -0,0 +1,23 @@
+package app.k9mail.feature.account.oauth.domain.usecase
+
+import app.k9mail.feature.account.oauth.domain.DomainContract.UseCase
+
+internal class CheckIsGoogleSignIn : UseCase.CheckIsGoogleSignIn {
+    override fun execute(hostname: String): Boolean {
+        for (domain in domainList) {
+            if (hostname.lowercase().endsWith(domain)) {
+                return true
+            }
+        }
+
+        return false
+    }
+
+    private companion object {
+        val domainList = listOf(
+            ".gmail.com",
+            ".googlemail.com",
+            ".google.com",
+        )
+    }
+}
diff --git a/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/domain/usecase/FinishOAuthSignIn.kt b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/domain/usecase/FinishOAuthSignIn.kt
new file mode 100644
index 0000000000000000000000000000000000000000..8b22d8fa04ef45866e58902cc676d629cdf98880
--- /dev/null
+++ b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/domain/usecase/FinishOAuthSignIn.kt
@@ -0,0 +1,23 @@
+package app.k9mail.feature.account.oauth.domain.usecase
+
+import android.content.Intent
+import app.k9mail.feature.account.oauth.domain.DomainContract
+import app.k9mail.feature.account.oauth.domain.DomainContract.UseCase
+import app.k9mail.feature.account.oauth.domain.entity.AuthorizationResult
+
+class FinishOAuthSignIn(
+    private val repository: DomainContract.AuthorizationRepository,
+) : UseCase.FinishOAuthSignIn {
+    override suspend fun execute(intent: Intent): AuthorizationResult {
+        val response = repository.getAuthorizationResponse(intent)
+        val exception = repository.getAuthorizationException(intent)
+
+        return if (response != null) {
+            repository.getExchangeToken(response)
+        } else if (exception != null) {
+            AuthorizationResult.Failure(exception)
+        } else {
+            AuthorizationResult.Canceled
+        }
+    }
+}
diff --git a/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/domain/usecase/GetOAuthRequestIntent.kt b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/domain/usecase/GetOAuthRequestIntent.kt
new file mode 100644
index 0000000000000000000000000000000000000000..ac8ad0f03cd2239541d1409e190c3e6059ea4988
--- /dev/null
+++ b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/domain/usecase/GetOAuthRequestIntent.kt
@@ -0,0 +1,18 @@
+package app.k9mail.feature.account.oauth.domain.usecase
+
+import app.k9mail.core.common.oauth.OAuthConfigurationProvider
+import app.k9mail.feature.account.oauth.domain.DomainContract
+import app.k9mail.feature.account.oauth.domain.DomainContract.UseCase.GetOAuthRequestIntent
+import app.k9mail.feature.account.oauth.domain.entity.AuthorizationIntentResult
+
+internal class GetOAuthRequestIntent(
+    private val repository: DomainContract.AuthorizationRepository,
+    private val configurationProvider: OAuthConfigurationProvider,
+) : GetOAuthRequestIntent {
+    override fun execute(hostname: String, emailAddress: String): AuthorizationIntentResult {
+        val configuration = configurationProvider.getConfiguration(hostname)
+            ?: return AuthorizationIntentResult.NotSupported
+
+        return repository.getAuthorizationRequestIntent(configuration, emailAddress)
+    }
+}
diff --git a/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/domain/usecase/SuggestServerName.kt b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/domain/usecase/SuggestServerName.kt
new file mode 100644
index 0000000000000000000000000000000000000000..6125730642aa6ceb57d63fb0f6f3a3ee6e1c7ea2
--- /dev/null
+++ b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/domain/usecase/SuggestServerName.kt
@@ -0,0 +1,14 @@
+package app.k9mail.feature.account.oauth.domain.usecase
+
+import app.k9mail.core.common.mail.Protocols
+import app.k9mail.feature.account.oauth.domain.DomainContract.UseCase
+
+@Deprecated("This is not needed anymore, remove once auth setup flow is updated")
+class SuggestServerName : UseCase.SuggestServerName {
+    override fun suggest(protocol: String, domain: String): String = when (protocol) {
+        Protocols.IMAP -> "imap.$domain"
+        Protocols.SMTP -> "smtp.$domain"
+        Protocols.POP3 -> "pop3.$domain"
+        else -> throw AssertionError("Missed case: $protocol")
+    }
+}
diff --git a/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/ui/AccountOAuthContent.kt b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/ui/AccountOAuthContent.kt
new file mode 100644
index 0000000000000000000000000000000000000000..798560d6a0dd9442a9535c41ea7321ec0ff96cba
--- /dev/null
+++ b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/ui/AccountOAuthContent.kt
@@ -0,0 +1,75 @@
+package app.k9mail.feature.account.oauth.ui
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.stringResource
+import app.k9mail.core.ui.compose.common.DevicePreviews
+import app.k9mail.core.ui.compose.designsystem.molecule.ErrorView
+import app.k9mail.core.ui.compose.designsystem.molecule.LoadingView
+import app.k9mail.core.ui.compose.theme.K9Theme
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
+import app.k9mail.feature.account.oauth.R
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract.Event
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract.State
+import app.k9mail.feature.account.oauth.ui.view.SignInView
+
+@Composable
+internal fun AccountOAuthContent(
+    state: State,
+    onEvent: (Event) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val resources = LocalContext.current.resources
+
+    Column(
+        modifier = Modifier
+            .testTag("AccountOAuthContent")
+            .then(modifier),
+        verticalArrangement = Arrangement.spacedBy(MainTheme.spacings.double, Alignment.CenterVertically),
+    ) {
+        if (state.isLoading) {
+            LoadingView(
+                message = stringResource(id = R.string.account_oauth_loading_message),
+            )
+        } else if (state.error != null) {
+            ErrorView(
+                title = stringResource(id = R.string.account_oauth_loading_error),
+                message = state.error.toResourceString(resources),
+                onRetry = { onEvent(Event.OnRetryClicked) },
+            )
+        } else {
+            SignInView(
+                onSignInClick = { onEvent(Event.SignInClicked) },
+                isGoogleSignIn = state.isGoogleSignIn,
+            )
+        }
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountOAuthContentK9Preview() {
+    K9Theme {
+        AccountOAuthContent(
+            state = State(),
+            onEvent = {},
+        )
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountOAuthContentThunderbirdPreview() {
+    ThunderbirdTheme {
+        AccountOAuthContent(
+            state = State(),
+            onEvent = {},
+        )
+    }
+}
diff --git a/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/ui/AccountOAuthContract.kt b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/ui/AccountOAuthContract.kt
new file mode 100644
index 0000000000000000000000000000000000000000..6b704f8c30758edcccff379ae9085641f2ae5d09
--- /dev/null
+++ b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/ui/AccountOAuthContract.kt
@@ -0,0 +1,54 @@
+package app.k9mail.feature.account.oauth.ui
+
+import android.content.Intent
+import app.k9mail.core.ui.compose.common.mvi.UnidirectionalViewModel
+import app.k9mail.feature.account.common.ui.WizardNavigationBarState
+import app.k9mail.feature.account.oauth.domain.entity.AuthorizationState
+
+interface AccountOAuthContract {
+
+    interface ViewModel : UnidirectionalViewModel<State, Event, Effect> {
+        fun initState(state: State)
+    }
+
+    data class State(
+        val hostname: String = "",
+        val emailAddress: String = "",
+        val wizardNavigationBarState: WizardNavigationBarState = WizardNavigationBarState(
+            isNextEnabled = false,
+        ),
+        val isGoogleSignIn: Boolean = false,
+        val error: Error? = null,
+        val isLoading: Boolean = false,
+    )
+
+    sealed interface Event {
+        data class OnOAuthResult(
+            val resultCode: Int,
+            val data: Intent?,
+        ) : Event
+
+        object SignInClicked : Event
+        object OnBackClicked : Event
+        object OnRetryClicked : Event
+    }
+
+    sealed interface Effect {
+        data class LaunchOAuth(
+            val intent: Intent,
+        ) : Effect
+
+        data class NavigateNext(
+            val state: AuthorizationState,
+        ) : Effect
+        object NavigateBack : Effect
+    }
+
+    sealed interface Error {
+        object NotSupported : Error
+        object Canceled : Error
+
+        object BrowserNotAvailable : Error
+        data class Unknown(val error: Exception) : Error
+    }
+}
diff --git a/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/ui/AccountOAuthStringMapper.kt b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/ui/AccountOAuthStringMapper.kt
new file mode 100644
index 0000000000000000000000000000000000000000..df9c7327d5d314f529616f07b4cd70349d972873
--- /dev/null
+++ b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/ui/AccountOAuthStringMapper.kt
@@ -0,0 +1,14 @@
+package app.k9mail.feature.account.oauth.ui
+
+import android.content.res.Resources
+import app.k9mail.feature.account.oauth.R
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract.Error
+
+internal fun Error.toResourceString(resources: Resources): String {
+    return when (this) {
+        Error.BrowserNotAvailable -> resources.getString(R.string.account_oauth_error_browser_not_available)
+        Error.Canceled -> resources.getString(R.string.account_oauth_error_canceled)
+        Error.NotSupported -> resources.getString(R.string.account_oauth_error_not_supported)
+        is Error.Unknown -> resources.getString(R.string.account_oauth_error_failed, error.message)
+    }
+}
diff --git a/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/ui/AccountOAuthView.kt b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/ui/AccountOAuthView.kt
new file mode 100644
index 0000000000000000000000000000000000000000..44f458a0d101dbacedff2e715c353cf45bde1a90
--- /dev/null
+++ b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/ui/AccountOAuthView.kt
@@ -0,0 +1,38 @@
+package app.k9mail.feature.account.oauth.ui
+
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import app.k9mail.core.ui.compose.common.mvi.observe
+import app.k9mail.feature.account.oauth.domain.entity.OAuthResult
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract.Effect
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract.Event
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract.ViewModel
+
+@Composable
+fun AccountOAuthView(
+    onOAuthResult: (OAuthResult) -> Unit,
+    viewModel: ViewModel,
+    modifier: Modifier = Modifier,
+) {
+    val oAuthLauncher = rememberLauncherForActivityResult(
+        contract = ActivityResultContracts.StartActivityForResult(),
+    ) {
+        viewModel.event(Event.OnOAuthResult(it.resultCode, it.data))
+    }
+
+    val (state, dispatch) = viewModel.observe { effect ->
+        when (effect) {
+            is Effect.NavigateNext -> onOAuthResult(OAuthResult.Success(effect.state))
+            is Effect.NavigateBack -> onOAuthResult(OAuthResult.Failure)
+            is Effect.LaunchOAuth -> oAuthLauncher.launch(effect.intent)
+        }
+    }
+
+    AccountOAuthContent(
+        state = state.value,
+        onEvent = { dispatch(it) },
+        modifier = modifier,
+    )
+}
diff --git a/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/ui/AccountOAuthViewModel.kt b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/ui/AccountOAuthViewModel.kt
new file mode 100644
index 0000000000000000000000000000000000000000..7204837a2e035ec3c3ea226bda94c6310c978e03
--- /dev/null
+++ b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/ui/AccountOAuthViewModel.kt
@@ -0,0 +1,120 @@
+package app.k9mail.feature.account.oauth.ui
+
+import android.app.Activity
+import android.content.Intent
+import androidx.lifecycle.viewModelScope
+import app.k9mail.core.ui.compose.common.mvi.BaseViewModel
+import app.k9mail.feature.account.oauth.domain.DomainContract.UseCase
+import app.k9mail.feature.account.oauth.domain.entity.AuthorizationIntentResult
+import app.k9mail.feature.account.oauth.domain.entity.AuthorizationResult
+import app.k9mail.feature.account.oauth.domain.entity.AuthorizationState
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract.Effect
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract.Error
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract.Event
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract.State
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract.ViewModel
+import kotlinx.coroutines.launch
+
+class AccountOAuthViewModel(
+    initialState: State = State(),
+    private val getOAuthRequestIntent: UseCase.GetOAuthRequestIntent,
+    private val finishOAuthSignIn: UseCase.FinishOAuthSignIn,
+    private val checkIsGoogleSignIn: UseCase.CheckIsGoogleSignIn,
+) : BaseViewModel<State, Event, Effect>(initialState), ViewModel {
+
+    override fun initState(state: State) {
+        val isGoogleSignIn = checkIsGoogleSignIn.execute(state.hostname)
+
+        updateState {
+            state.copy(
+                isGoogleSignIn = isGoogleSignIn,
+            )
+        }
+    }
+
+    override fun event(event: Event) {
+        when (event) {
+            is Event.OnOAuthResult -> onOAuthResult(event.resultCode, event.data)
+
+            Event.SignInClicked -> onSignIn()
+
+            Event.OnBackClicked -> navigateBack()
+
+            Event.OnRetryClicked -> onRetry()
+        }
+    }
+
+    private fun onSignIn() {
+        val result = getOAuthRequestIntent.execute(
+            hostname = state.value.hostname,
+            emailAddress = state.value.emailAddress,
+        )
+
+        when (result) {
+            AuthorizationIntentResult.NotSupported -> {
+                updateState { state ->
+                    state.copy(
+                        error = Error.NotSupported,
+                    )
+                }
+            }
+
+            is AuthorizationIntentResult.Success -> {
+                emitEffect(Effect.LaunchOAuth(result.intent))
+            }
+        }
+    }
+
+    private fun onRetry() {
+        updateState { state ->
+            state.copy(
+                error = null,
+            )
+        }
+        onSignIn()
+    }
+
+    private fun onOAuthResult(resultCode: Int, data: Intent?) {
+        if (resultCode == Activity.RESULT_OK && data != null) {
+            finishSignIn(data)
+        } else {
+            updateState { state ->
+                state.copy(error = Error.Canceled)
+            }
+        }
+    }
+
+    private fun finishSignIn(data: Intent) {
+        updateState { state ->
+            state.copy(
+                isLoading = true,
+            )
+        }
+        viewModelScope.launch {
+            when (val result = finishOAuthSignIn.execute(data)) {
+                AuthorizationResult.BrowserNotAvailable -> updateErrorState(Error.BrowserNotAvailable)
+                AuthorizationResult.Canceled -> updateErrorState(Error.Canceled)
+                is AuthorizationResult.Failure -> updateErrorState(Error.Unknown(result.error))
+                is AuthorizationResult.Success -> {
+                    updateState { state ->
+                        state.copy(isLoading = false)
+                    }
+                    navigateNext(authorizationState = result.state)
+                }
+            }
+        }
+    }
+
+    private fun updateErrorState(error: Error) = updateState { state ->
+        state.copy(
+            error = error,
+            isLoading = false,
+        )
+    }
+
+    private fun navigateBack() = emitEffect(Effect.NavigateBack)
+
+    private fun navigateNext(authorizationState: AuthorizationState) {
+        emitEffect(Effect.NavigateNext(authorizationState))
+    }
+}
diff --git a/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/ui/preview/PreviewAccountOAuthViewModel.kt b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/ui/preview/PreviewAccountOAuthViewModel.kt
new file mode 100644
index 0000000000000000000000000000000000000000..a7e54014e74415d336044f7fe871373e120f99fa
--- /dev/null
+++ b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/ui/preview/PreviewAccountOAuthViewModel.kt
@@ -0,0 +1,17 @@
+package app.k9mail.feature.account.oauth.ui.preview
+
+import app.k9mail.core.ui.compose.common.mvi.BaseViewModel
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract
+
+/**
+ * Only for previewing the UI.
+ */
+class PreviewAccountOAuthViewModel :
+    BaseViewModel<AccountOAuthContract.State, AccountOAuthContract.Event, AccountOAuthContract.Effect>(
+        AccountOAuthContract.State(),
+    ),
+    AccountOAuthContract.ViewModel {
+
+    override fun initState(state: AccountOAuthContract.State) = Unit
+    override fun event(event: AccountOAuthContract.Event) = Unit
+}
diff --git a/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/ui/view/SignInView.kt b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/ui/view/SignInView.kt
new file mode 100644
index 0000000000000000000000000000000000000000..7a711c7e32130041cd695c26ce6d7de6e9306230
--- /dev/null
+++ b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/ui/view/SignInView.kt
@@ -0,0 +1,61 @@
+package app.k9mail.feature.account.oauth.ui.view
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.style.TextAlign
+import app.k9mail.core.ui.compose.common.DevicePreviews
+import app.k9mail.core.ui.compose.designsystem.atom.button.Button
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextCaption
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.feature.account.oauth.R
+
+@Composable
+internal fun SignInView(
+    onSignInClick: () -> Unit,
+    isGoogleSignIn: Boolean,
+    modifier: Modifier = Modifier,
+) {
+    Column(
+        horizontalAlignment = Alignment.CenterHorizontally,
+        verticalArrangement = Arrangement.spacedBy(MainTheme.spacings.double),
+        modifier = modifier,
+    ) {
+        TextCaption(
+            text = stringResource(id = R.string.account_oauth_sign_in_description),
+            textAlign = TextAlign.Center,
+        )
+
+        if (isGoogleSignIn) {
+            SignInWithGoogleButton(
+                onClick = onSignInClick,
+            )
+        } else {
+            Button(
+                text = stringResource(id = R.string.account_oauth_sign_in_button),
+                onClick = onSignInClick,
+            )
+        }
+    }
+}
+
+@DevicePreviews
+@Composable
+internal fun SignInViewPreview() {
+    SignInView(
+        onSignInClick = {},
+        isGoogleSignIn = false,
+    )
+}
+
+@DevicePreviews
+@Composable
+internal fun SignInViewWithGooglePreview() {
+    SignInView(
+        onSignInClick = {},
+        isGoogleSignIn = true,
+    )
+}
diff --git a/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/ui/view/SignInWithGoogleButton.kt b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/ui/view/SignInWithGoogleButton.kt
new file mode 100644
index 0000000000000000000000000000000000000000..8a5ef0064ed807f1319e4cc8a4b30f018dd80d8f
--- /dev/null
+++ b/feature/account/oauth/src/main/kotlin/app/k9mail/feature/account/oauth/ui/view/SignInWithGoogleButton.kt
@@ -0,0 +1,141 @@
+package app.k9mail.feature.account.oauth.ui.view
+
+import androidx.compose.animation.animateContentSize
+import androidx.compose.animation.core.LinearOutSlowInEasing
+import androidx.compose.animation.core.tween
+import androidx.compose.foundation.border
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.requiredWidth
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.ButtonDefaults
+import androidx.compose.material.ButtonElevation
+import androidx.compose.material.Icon
+import androidx.compose.material.MaterialTheme
+import androidx.compose.material.Surface
+import androidx.compose.material.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import app.k9mail.core.ui.compose.common.DevicePreviews
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+import app.k9mail.feature.account.oauth.R
+
+/**
+ * A sign in with Google button, following the Google Branding Guidelines.
+ *
+ * @see [Google Branding Guidelines](https://developers.google.com/identity/branding-guidelines)
+ */
+@Suppress("LongMethod")
+@Composable
+fun SignInWithGoogleButton(
+    onClick: () -> Unit,
+    modifier: Modifier = Modifier,
+    isLight: Boolean = MaterialTheme.colors.isLight,
+    interactionSource: MutableInteractionSource = remember { MutableInteractionSource() },
+    elevation: ButtonElevation? = ButtonDefaults.elevation(),
+) {
+    Surface(
+        modifier = Modifier
+            .border(
+                width = 1.dp,
+                color = getBorderColor(isLight),
+                shape = RoundedCornerShape(8.dp),
+            )
+            .clickable { onClick() }
+            .then(modifier),
+        shape = RoundedCornerShape(8.dp),
+        color = getSurfaceColor(isLight),
+        elevation = elevation?.elevation(true, interactionSource)?.value ?: 0.dp,
+    ) {
+        Row(
+            modifier = Modifier
+                .animateContentSize(
+                    animationSpec = tween(
+                        durationMillis = 300,
+                        easing = LinearOutSlowInEasing,
+                    ),
+                )
+                .padding(
+                    end = 8.dp,
+                ),
+
+            verticalAlignment = Alignment.CenterVertically,
+        ) {
+            Surface(
+                shape = RoundedCornerShape(2.dp),
+                color = Color.White,
+            ) {
+                Icon(
+                    modifier = Modifier
+                        .padding(8.dp),
+                    painter = painterResource(
+                        id = R.drawable.account_oauth_ic_google_logo,
+                    ),
+                    contentDescription = "Google logo",
+                    tint = Color.Unspecified,
+                )
+            }
+            Spacer(modifier = Modifier.requiredWidth(8.dp))
+            Text(
+                text = stringResource(
+                    id = R.string.account_oauth_sign_in_with_google_button,
+                ),
+                style = TextStyle(
+                    color = getTextColor(isLight),
+                    fontWeight = FontWeight.Medium,
+                    fontSize = 14.sp,
+                    letterSpacing = 1.25.sp,
+                ),
+            )
+        }
+    }
+}
+
+@Suppress("MagicNumber")
+private fun getBorderColor(isLight: Boolean): Color {
+    return if (isLight) {
+        Color(0x87000000)
+    } else {
+        Color(0xFF4285F4)
+    }
+}
+
+@Suppress("MagicNumber")
+private fun getSurfaceColor(isLight: Boolean): Color {
+    return if (isLight) {
+        Color(0xFFFFFFFF)
+    } else {
+        Color(0xFF4285F4)
+    }
+}
+
+@Suppress("MagicNumber")
+private fun getTextColor(isLight: Boolean): Color {
+    return if (isLight) {
+        Color(0x87000000)
+    } else {
+        Color(0xFFFFFFFF)
+    }
+}
+
+@DevicePreviews
+@Composable
+internal fun SignInWithGoogleButtonPreview() {
+    PreviewWithThemes {
+        SignInWithGoogleButton(
+            onClick = {},
+        )
+    }
+}
diff --git a/feature/account/oauth/src/main/res/drawable/account_oauth_ic_google_logo.xml b/feature/account/oauth/src/main/res/drawable/account_oauth_ic_google_logo.xml
new file mode 100644
index 0000000000000000000000000000000000000000..65e3f4e0bad89626619ce6459eaefefab45d9687
--- /dev/null
+++ b/feature/account/oauth/src/main/res/drawable/account_oauth_ic_google_logo.xml
@@ -0,0 +1,18 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:pathData="M21.7428,12.2242a11.534,11.534 0,0 0,-0.158 -1.883h-9.375v3.742h5.368a4.622,4.622 0,0 1,-1.991 2.97L15.5868,19.5422h3.2A9.734,9.734 0,0 0,21.7428 12.2242Z"
+        android:fillColor="#4285f4"/>
+    <path
+        android:pathData="M12.2098,21.9562A9.483,9.483 0,0 0,18.7888 19.5412l-3.2,-2.489a6.006,6.006 0,0 1,-3.377 0.962,5.946 5.946,0 0,1 -5.583,-4.115h-3.3v2.564A9.941,9.941 0,0 0,12.2098 21.9562Z"
+        android:fillColor="#34a853"/>
+    <path
+        android:pathData="M6.6268,13.9002a5.777,5.777 0,0 1,-0.315 -1.9,6 6,0 0,1 0.315,-1.9L6.6268,7.5372h-3.3a9.84,9.84 0,0 0,-1.07 4.463,9.84 9.84,0 0,0 1.07,4.463Z"
+        android:fillColor="#fbbc05"/>
+    <path
+        android:pathData="M12.2098,5.9862a5.4,5.4 0,0 1,3.816 1.493l2.837,-2.837a9.518,9.518 0,0 0,-6.654 -2.6,9.941 9.941,0 0,0 -8.885,5.492l3.3,2.564A5.946,5.946 0,0 1,12.2098 5.9862Z"
+        android:fillColor="#ea4335"/>
+</vector>
diff --git a/feature/account/oauth/src/main/res/values/strings.xml b/feature/account/oauth/src/main/res/values/strings.xml
new file mode 100644
index 0000000000000000000000000000000000000000..533223b5b8124549d6fe55d6d53a19318e473c57
--- /dev/null
+++ b/feature/account/oauth/src/main/res/values/strings.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="account_oauth_sign_in_description">We\'ll redirect you to your email provider to sign in. You need to grant the app access to your email account.</string>
+    <string name="account_oauth_sign_in_button">Sign in</string>
+    <string name="account_oauth_sign_in_with_google_button">Sign in with Google</string>
+    <string name="account_oauth_loading_message">Signing in using OAuth</string>
+    <string name="account_oauth_loading_error">OAuth sign in failed</string>
+
+    <string name="account_oauth_error_canceled">Authorization canceled</string>
+    <string name="account_oauth_error_failed">Authorization failed with the following error: <xliff:g id="error">%s</xliff:g></string>
+    <string name="account_oauth_error_not_supported">OAuth 2.0 is currently not supported with this provider.</string>
+    <string name="account_oauth_error_browser_not_available">The app couldn\'t find a browser to use for granting access to your account.</string>
+
+</resources>
diff --git a/feature/account/oauth/src/test/kotlin/app/k9mail/feature/account/oauth/data/AuthorizationRepositoryTest.kt b/feature/account/oauth/src/test/kotlin/app/k9mail/feature/account/oauth/data/AuthorizationRepositoryTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..78cce14918fa7773fa12d341c8a3a257efa78af0
--- /dev/null
+++ b/feature/account/oauth/src/test/kotlin/app/k9mail/feature/account/oauth/data/AuthorizationRepositoryTest.kt
@@ -0,0 +1,257 @@
+package app.k9mail.feature.account.oauth.data
+
+import android.content.Intent
+import android.net.Uri
+import androidx.core.net.toUri
+import app.k9mail.core.common.oauth.OAuthConfiguration
+import app.k9mail.feature.account.oauth.domain.entity.AuthorizationIntentResult
+import app.k9mail.feature.account.oauth.domain.entity.AuthorizationResult
+import assertk.all
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.isNotNull
+import assertk.assertions.isNull
+import assertk.assertions.prop
+import kotlinx.coroutines.test.runTest
+import net.openid.appauth.AuthState
+import net.openid.appauth.AuthorizationException
+import net.openid.appauth.AuthorizationRequest
+import net.openid.appauth.AuthorizationResponse
+import net.openid.appauth.AuthorizationService
+import net.openid.appauth.AuthorizationService.TokenResponseCallback
+import net.openid.appauth.AuthorizationServiceConfiguration
+import net.openid.appauth.GrantTypeValues
+import net.openid.appauth.ResponseTypeValues
+import net.openid.appauth.TokenRequest
+import net.openid.appauth.TokenResponse
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.kotlin.any
+import org.mockito.kotlin.argumentCaptor
+import org.mockito.kotlin.doAnswer
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.stub
+import org.robolectric.RobolectricTestRunner
+
+@RunWith(RobolectricTestRunner::class)
+class AuthorizationRepositoryTest {
+
+    private val service: AuthorizationService = mock<AuthorizationService>()
+
+    @Test
+    fun `getAuthorizationRequestIntent should return Success with intent when hostname has oauth configuration`() =
+        runTest {
+            val testSubject = AuthorizationRepository(
+                service = service,
+            )
+            val emailAddress = "emailAddress"
+            val intent = Intent()
+            val authRequestCapture = argumentCaptor<AuthorizationRequest>().apply {
+                service.stub { on { getAuthorizationRequestIntent(capture()) }.thenReturn(intent) }
+            }
+
+            // When
+            val result = testSubject.getAuthorizationRequestIntent(oAuthConfiguration, emailAddress)
+
+            // Then
+            assertThat(result).isEqualTo(
+                AuthorizationIntentResult.Success(
+                    intent = intent,
+                ),
+            )
+            assertThat(authRequestCapture.firstValue).all {
+                prop(AuthorizationRequest::configuration).all {
+                    prop(AuthorizationServiceConfiguration::authorizationEndpoint).isEqualTo(
+                        oAuthConfiguration.authorizationEndpoint.toUri(),
+                    )
+                    prop(AuthorizationServiceConfiguration::tokenEndpoint).isEqualTo(
+                        oAuthConfiguration.tokenEndpoint.toUri(),
+                    )
+                }
+                prop(AuthorizationRequest::clientId).isEqualTo(oAuthConfiguration.clientId)
+                prop(AuthorizationRequest::responseType).isEqualTo(ResponseTypeValues.CODE)
+                prop(AuthorizationRequest::redirectUri).isEqualTo(oAuthConfiguration.redirectUri.toUri())
+                prop(AuthorizationRequest::scope).isEqualTo("scope scope2")
+                prop(AuthorizationRequest::codeVerifier).isNull()
+                prop(AuthorizationRequest::loginHint).isEqualTo(emailAddress)
+            }
+        }
+
+    @Test
+    fun `getAuthorizationResponse should return AuthorizationResponse when intent invalid`() = runTest {
+        val testSubject = AuthorizationRepository(
+            service = service,
+        )
+        val intent = Intent().also {
+            it.putExtra(AuthorizationResponse.EXTRA_RESPONSE, authorizationResponse.jsonSerializeString())
+        }
+
+        // When
+        val result = testSubject.getAuthorizationResponse(intent)
+
+        // Then
+        assertThat(result).isNotNull().all {
+            prop(AuthorizationResponse::request).all {
+                prop(AuthorizationRequest::configuration).all {
+                    prop(AuthorizationServiceConfiguration::authorizationEndpoint).isEqualTo(
+                        authorizationConfiguration.authorizationEndpoint,
+                    )
+                    prop(AuthorizationServiceConfiguration::tokenEndpoint).isEqualTo(
+                        authorizationConfiguration.tokenEndpoint,
+                    )
+                }
+                prop(AuthorizationRequest::clientId).isEqualTo(authorizationRequest.clientId)
+                prop(AuthorizationRequest::responseType).isEqualTo(authorizationRequest.responseType)
+                prop(AuthorizationRequest::redirectUri).isEqualTo(authorizationRequest.redirectUri)
+            }
+        }
+    }
+
+    @Test
+    fun `getAuthorizationResponse should return null when intent is invalid`() = runTest {
+        val testSubject = AuthorizationRepository(
+            service = service,
+        )
+        val intent = Intent()
+
+        // When
+        val result = testSubject.getAuthorizationResponse(intent)
+
+        // Then
+        assertThat(result).isNull()
+    }
+
+    @Test
+    fun `getAuthorizationException should return AuthorizationException when intent is valid`() = runTest {
+        val testSubject = AuthorizationRepository(
+            service = service,
+        )
+        val authorizationException = AuthorizationException(
+            AuthorizationException.TYPE_OAUTH_AUTHORIZATION_ERROR,
+            1,
+            "error",
+            "errorDescription",
+            Uri.parse("https://example.com/errorUri"),
+            null,
+        )
+        val intent = Intent().also {
+            it.putExtra(AuthorizationException.EXTRA_EXCEPTION, authorizationException.toJsonString())
+        }
+
+        // When
+        val result = testSubject.getAuthorizationException(intent)
+
+        // Then
+        assertThat(result).isEqualTo(authorizationException)
+    }
+
+    @Test
+    fun `getAuthorizationException should return null when intent is invalid`() = runTest {
+        val testSubject = AuthorizationRepository(
+            service = service,
+        )
+        val intent = Intent()
+
+        // When
+        val result = testSubject.getAuthorizationException(intent)
+
+        // Then
+        assertThat(result).isNull()
+    }
+
+    @Test
+    fun `getExchangeToken should return success when tokenRequest successful`() = runTest {
+        val testSubject = AuthorizationRepository(
+            service = service,
+        )
+        val tokenRequest = TokenRequest.Builder(
+            authorizationConfiguration,
+            authorizationRequest.clientId,
+        ).setGrantType(GrantTypeValues.AUTHORIZATION_CODE)
+            .setAuthorizationCode("authorizationCode")
+            .setRedirectUri(authorizationRequest.redirectUri)
+            .build()
+        val tokenResponse = TokenResponse.Builder(tokenRequest)
+            .build()
+        service.stub {
+            on { performTokenRequest(any(), any()) } doAnswer {
+                val callback = it.getArgument(1, TokenResponseCallback::class.java)
+                callback.onTokenRequestCompleted(tokenResponse, null)
+            }
+        }
+
+        val result = testSubject.getExchangeToken(authorizationResponse)
+
+        val expectedAuthState = AuthState(authorizationResponse, tokenResponse, null)
+        val successAuthorizationState = expectedAuthState.toAuthorizationState()
+
+        assertThat(result).isEqualTo(AuthorizationResult.Success(successAuthorizationState))
+    }
+
+    fun `getExchangeToken should return failure when tokenRequest failure`() = runTest {
+        val testSubject = AuthorizationRepository(
+            service = service,
+        )
+        val authorizationException = AuthorizationException(
+            AuthorizationException.TYPE_OAUTH_AUTHORIZATION_ERROR,
+            1,
+            "error",
+            "errorDescription",
+            Uri.parse("https://example.com/errorUri"),
+            null,
+        )
+        service.stub {
+            on { performTokenRequest(any(), any()) } doAnswer {
+                val callback = it.getArgument(1, TokenResponseCallback::class.java)
+                callback.onTokenRequestCompleted(null, authorizationException)
+            }
+        }
+
+        val result = testSubject.getExchangeToken(authorizationResponse)
+
+        assertThat(result).isEqualTo(AuthorizationResult.Failure(authorizationException))
+    }
+
+    fun `getExchangeToken should return unknown failure when tokenRequest null for response and exception`() = runTest {
+        val testSubject = AuthorizationRepository(
+            service = service,
+        )
+        val exception = Exception("Unknown error")
+        service.stub {
+            on { performTokenRequest(any(), any()) } doAnswer {
+                val callback = it.getArgument(1, TokenResponseCallback::class.java)
+                callback.onTokenRequestCompleted(null, null)
+            }
+        }
+
+        val result = testSubject.getExchangeToken(authorizationResponse)
+
+        assertThat(result).isEqualTo(AuthorizationResult.Failure(exception))
+    }
+
+    private companion object {
+        val oAuthConfiguration = OAuthConfiguration(
+            clientId = "clientId",
+            scopes = listOf("scope", "scope2"),
+            authorizationEndpoint = "auth.example.com",
+            tokenEndpoint = "token.example.com",
+            redirectUri = "redirect.example.com",
+        )
+
+        val authorizationConfiguration = AuthorizationServiceConfiguration(
+            Uri.parse("https://example.com/authorize"),
+            Uri.parse("https://example.com/token"),
+        )
+
+        val authorizationRequest = AuthorizationRequest.Builder(
+            authorizationConfiguration,
+            "clientId",
+            "responseType",
+            Uri.parse("https://example.com/redirectUri"),
+        ).build()
+
+        val authorizationResponse = AuthorizationResponse.Builder(authorizationRequest)
+            .setAuthorizationCode("authorizationCode")
+            .build()
+    }
+}
diff --git a/feature/account/oauth/src/test/kotlin/app/k9mail/feature/account/oauth/data/AuthorizationStateRepositoryTest.kt b/feature/account/oauth/src/test/kotlin/app/k9mail/feature/account/oauth/data/AuthorizationStateRepositoryTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..1811403fb551997b13c0dfec02ad0cb4a7f86dc7
--- /dev/null
+++ b/feature/account/oauth/src/test/kotlin/app/k9mail/feature/account/oauth/data/AuthorizationStateRepositoryTest.kt
@@ -0,0 +1,54 @@
+package app.k9mail.feature.account.oauth.data
+
+import android.net.Uri
+import assertk.assertThat
+import assertk.assertions.isFalse
+import assertk.assertions.isTrue
+import kotlinx.coroutines.test.runTest
+import net.openid.appauth.AuthState
+import net.openid.appauth.AuthorizationServiceConfiguration
+import net.openid.appauth.TokenRequest
+import net.openid.appauth.TokenResponse
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+@RunWith(RobolectricTestRunner::class)
+class AuthorizationStateRepositoryTest {
+
+    @Test
+    fun `should return false with unauthorized auth state`() = runTest {
+        val authState = AuthState()
+        val authorizationState = authState.toAuthorizationState()
+        val testSubject = AuthorizationStateRepository()
+
+        val result = testSubject.isAuthorized(authorizationState)
+
+        assertThat(result).isFalse()
+    }
+
+    @Test
+    fun `should return true with authorized auth state`() = runTest {
+        val authState = AuthState()
+        val clientId = "clientId"
+        val configuration = AuthorizationServiceConfiguration(
+            Uri.parse("https://example.com"),
+            Uri.parse("https://example.com"),
+        )
+        val tokenRequest = TokenRequest.Builder(configuration, clientId)
+            .setGrantType(TokenRequest.GRANT_TYPE_PASSWORD)
+            .build()
+        val tokenResponse = TokenResponse.Builder(tokenRequest)
+            .setAccessToken("accessToken")
+            .setIdToken("idToken")
+            .build()
+        authState.update(tokenResponse, null)
+        val authorizationState = authState.toAuthorizationState()
+
+        val testSubject = AuthorizationStateRepository()
+
+        val result = testSubject.isAuthorized(authorizationState)
+
+        assertThat(result).isTrue()
+    }
+}
diff --git a/feature/account/oauth/src/test/kotlin/app/k9mail/feature/account/oauth/domain/FakeAuthorizationRepository.kt b/feature/account/oauth/src/test/kotlin/app/k9mail/feature/account/oauth/domain/FakeAuthorizationRepository.kt
new file mode 100644
index 0000000000000000000000000000000000000000..7c5d4c0f98bc8dc13738bfe9174adf96bfd78885
--- /dev/null
+++ b/feature/account/oauth/src/test/kotlin/app/k9mail/feature/account/oauth/domain/FakeAuthorizationRepository.kt
@@ -0,0 +1,50 @@
+package app.k9mail.feature.account.oauth.domain
+
+import android.content.Intent
+import app.k9mail.core.common.oauth.OAuthConfiguration
+import app.k9mail.feature.account.oauth.domain.entity.AuthorizationIntentResult
+import app.k9mail.feature.account.oauth.domain.entity.AuthorizationResult
+import net.openid.appauth.AuthorizationException
+import net.openid.appauth.AuthorizationResponse
+
+class FakeAuthorizationRepository(
+    private val answerGetAuthorizationRequestIntent: AuthorizationIntentResult = AuthorizationIntentResult.NotSupported,
+    private val answerGetAuthorizationResponse: AuthorizationResponse? = null,
+    private val answerGetAuthorizationException: AuthorizationException? = null,
+    private val answerGetExchangeToken: AuthorizationResult = AuthorizationResult.Canceled,
+) : DomainContract.AuthorizationRepository {
+
+    var recordedGetAuthorizationRequestIntentConfiguration: OAuthConfiguration? = null
+    var recordedGetAuthorizationRequestIntentEmailAddress: String? = null
+    override fun getAuthorizationRequestIntent(
+        configuration: OAuthConfiguration,
+        emailAddress: String,
+    ): AuthorizationIntentResult {
+        recordedGetAuthorizationRequestIntentConfiguration = configuration
+        recordedGetAuthorizationRequestIntentEmailAddress = emailAddress
+        return answerGetAuthorizationRequestIntent
+    }
+
+    var recordedGetAuthorizationResponseIntent: Intent? = null
+
+    override suspend fun getAuthorizationResponse(intent: Intent): AuthorizationResponse? {
+        recordedGetAuthorizationResponseIntent = intent
+        return answerGetAuthorizationResponse
+    }
+
+    var recordedGetAuthorizationExceptionIntent: Intent? = null
+
+    override suspend fun getAuthorizationException(intent: Intent): AuthorizationException? {
+        recordedGetAuthorizationExceptionIntent = intent
+        return answerGetAuthorizationException
+    }
+
+    var recordedGetExchangeTokenResponse: AuthorizationResponse? = null
+
+    override suspend fun getExchangeToken(
+        response: AuthorizationResponse,
+    ): AuthorizationResult {
+        recordedGetExchangeTokenResponse = response
+        return answerGetExchangeToken
+    }
+}
diff --git a/feature/account/oauth/src/test/kotlin/app/k9mail/feature/account/oauth/domain/usecase/CheckIsGoogleSignInTest.kt b/feature/account/oauth/src/test/kotlin/app/k9mail/feature/account/oauth/domain/usecase/CheckIsGoogleSignInTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..e6605d794a136e2b3ecacff6a0039fc47b3bef4e
--- /dev/null
+++ b/feature/account/oauth/src/test/kotlin/app/k9mail/feature/account/oauth/domain/usecase/CheckIsGoogleSignInTest.kt
@@ -0,0 +1,37 @@
+package app.k9mail.feature.account.oauth.domain.usecase
+
+import assertk.assertThat
+import assertk.assertions.isFalse
+import assertk.assertions.isTrue
+import org.junit.Test
+
+class CheckIsGoogleSignInTest {
+
+    private val testSubject = CheckIsGoogleSignIn()
+
+    @Test
+    fun `should return true when hostname ends with a google domain`() {
+        val hostnames = listOf(
+            "mail.gmail.com",
+            "mail.googlemail.com",
+            "mail.google.com",
+        )
+
+        for (hostname in hostnames) {
+            assertThat(testSubject.execute(hostname)).isTrue()
+        }
+    }
+
+    @Test
+    fun `should return false when hostname does not end with a google domain`() {
+        val hostnames = listOf(
+            "mail.example.com",
+            "mail.example.org",
+            "mail.example.net",
+        )
+
+        for (hostname in hostnames) {
+            assertThat(testSubject.execute(hostname)).isFalse()
+        }
+    }
+}
diff --git a/feature/account/oauth/src/test/kotlin/app/k9mail/feature/account/oauth/domain/usecase/FinishOAuthSignInTest.kt b/feature/account/oauth/src/test/kotlin/app/k9mail/feature/account/oauth/domain/usecase/FinishOAuthSignInTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..5a23e751704e18910edf6c7e1c7d2edf952fcf2b
--- /dev/null
+++ b/feature/account/oauth/src/test/kotlin/app/k9mail/feature/account/oauth/domain/usecase/FinishOAuthSignInTest.kt
@@ -0,0 +1,83 @@
+package app.k9mail.feature.account.oauth.domain.usecase
+
+import android.content.Intent
+import app.k9mail.feature.account.oauth.domain.FakeAuthorizationRepository
+import app.k9mail.feature.account.oauth.domain.entity.AuthorizationResult
+import app.k9mail.feature.account.oauth.domain.entity.AuthorizationState
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import kotlinx.coroutines.test.runTest
+import net.openid.appauth.AuthorizationException
+import net.openid.appauth.AuthorizationResponse
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.Mockito.mock
+import org.robolectric.RobolectricTestRunner
+
+@RunWith(RobolectricTestRunner::class)
+class FinishOAuthSignInTest {
+
+    @Test
+    fun `should return failure when intent has encoded exception`() = runTest {
+        val intent = Intent()
+        val exception = AuthorizationException(
+            AuthorizationException.TYPE_GENERAL_ERROR,
+            1,
+            "error",
+            "error_description",
+            null,
+            null,
+        )
+        val repository = FakeAuthorizationRepository(
+            answerGetAuthorizationException = exception,
+        )
+        val testSubject = FinishOAuthSignIn(
+            repository = repository,
+        )
+
+        val result = testSubject.execute(intent)
+
+        assertThat(result).isEqualTo(AuthorizationResult.Failure(exception))
+        assertThat(repository.recordedGetAuthorizationExceptionIntent).isEqualTo(intent)
+    }
+
+    @Test
+    fun `should return canceled when intent has no response and no exception`() = runTest {
+        val intent = Intent()
+        val repository = FakeAuthorizationRepository(
+            answerGetAuthorizationResponse = null,
+            answerGetAuthorizationException = null,
+        )
+        val testSubject = FinishOAuthSignIn(
+            repository = repository,
+        )
+
+        val result = testSubject.execute(intent)
+
+        assertThat(result).isEqualTo(AuthorizationResult.Canceled)
+        assertThat(repository.recordedGetAuthorizationResponseIntent).isEqualTo(intent)
+        assertThat(repository.recordedGetAuthorizationExceptionIntent).isEqualTo(intent)
+    }
+
+    @Test
+    fun `should return success when intent has response`() = runTest {
+        val authorizationState = AuthorizationState()
+        val intent = Intent()
+        val response = mock<AuthorizationResponse>()
+        val repository = FakeAuthorizationRepository(
+            answerGetAuthorizationResponse = response,
+            answerGetAuthorizationException = null,
+            answerGetExchangeToken = AuthorizationResult.Success(authorizationState),
+        )
+        val testSubject = FinishOAuthSignIn(
+            repository = repository,
+        )
+
+        val result = testSubject.execute(intent)
+
+        assertThat(result).isEqualTo(AuthorizationResult.Success(authorizationState))
+        assertThat(repository.recordedGetAuthorizationResponseIntent).isEqualTo(intent)
+        assertThat(repository.recordedGetAuthorizationExceptionIntent).isEqualTo(intent)
+        assertThat(repository.recordedGetExchangeTokenResponse).isEqualTo(response)
+    }
+}
diff --git a/feature/account/oauth/src/test/kotlin/app/k9mail/feature/account/oauth/domain/usecase/GetOAuthRequestIntentTest.kt b/feature/account/oauth/src/test/kotlin/app/k9mail/feature/account/oauth/domain/usecase/GetOAuthRequestIntentTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..422dcfc9d556202e1c891780437f2892824efc36
--- /dev/null
+++ b/feature/account/oauth/src/test/kotlin/app/k9mail/feature/account/oauth/domain/usecase/GetOAuthRequestIntentTest.kt
@@ -0,0 +1,61 @@
+package app.k9mail.feature.account.oauth.domain.usecase
+
+import android.content.Intent
+import app.k9mail.core.common.oauth.OAuthConfiguration
+import app.k9mail.feature.account.oauth.domain.FakeAuthorizationRepository
+import app.k9mail.feature.account.oauth.domain.entity.AuthorizationIntentResult
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+class GetOAuthRequestIntentTest {
+
+    @Test
+    fun `should return NotSupported when hostname has no oauth configuration`() = runTest {
+        val testSubject = GetOAuthRequestIntent(
+            repository = FakeAuthorizationRepository(),
+            configurationProvider = { null },
+        )
+        val hostname = "hostname"
+        val emailAddress = "emailAddress"
+
+        val result = testSubject.execute(hostname, emailAddress)
+
+        assertThat(result).isEqualTo(AuthorizationIntentResult.NotSupported)
+    }
+
+    @Test
+    fun `should return Success when repository has intent`() = runTest {
+        val intent = Intent()
+        val repository = FakeAuthorizationRepository(
+            answerGetAuthorizationRequestIntent = AuthorizationIntentResult.Success(intent),
+        )
+        val testSubject = GetOAuthRequestIntent(
+            repository = repository,
+            configurationProvider = { oAuthConfiguration },
+        )
+        val hostname = "hostname"
+        val emailAddress = "emailAddress"
+
+        val result = testSubject.execute(hostname, emailAddress)
+
+        assertThat(result).isEqualTo(
+            AuthorizationIntentResult.Success(
+                intent = intent,
+            ),
+        )
+        assertThat(repository.recordedGetAuthorizationRequestIntentConfiguration).isEqualTo(oAuthConfiguration)
+        assertThat(repository.recordedGetAuthorizationRequestIntentEmailAddress).isEqualTo(emailAddress)
+    }
+
+    private companion object {
+        val oAuthConfiguration = OAuthConfiguration(
+            clientId = "clientId",
+            scopes = listOf("scope", "scope2"),
+            authorizationEndpoint = "auth.example.com",
+            tokenEndpoint = "token.example.com",
+            redirectUri = "redirect.example.com",
+        )
+    }
+}
diff --git a/feature/account/oauth/src/test/kotlin/app/k9mail/feature/account/oauth/domain/usecase/SuggestServerNameTest.kt b/feature/account/oauth/src/test/kotlin/app/k9mail/feature/account/oauth/domain/usecase/SuggestServerNameTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..4c47c5786052d1f45bd40a214b9e584b8b6ab1b2
--- /dev/null
+++ b/feature/account/oauth/src/test/kotlin/app/k9mail/feature/account/oauth/domain/usecase/SuggestServerNameTest.kt
@@ -0,0 +1,41 @@
+package app.k9mail.feature.account.oauth.domain.usecase
+
+import app.k9mail.core.common.mail.Protocols
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import org.junit.Test
+
+class SuggestServerNameTest {
+
+    private val testSubject = SuggestServerName()
+
+    @Test
+    fun `should suggest server name for IMAP server`() {
+        val serverType = Protocols.IMAP
+        val domain = "example.org"
+
+        val result = testSubject.suggest(serverType, domain)
+
+        assertThat(result).isEqualTo("imap.example.org")
+    }
+
+    @Test
+    fun `should suggest server name for POP3 server`() {
+        val serverType = Protocols.POP3
+        val domain = "example.org"
+
+        val result = testSubject.suggest(serverType, domain)
+
+        assertThat(result).isEqualTo("pop3.example.org")
+    }
+
+    @Test
+    fun `should suggest server name for SMTP server`() {
+        val serverType = Protocols.SMTP
+        val domain = "example.org"
+
+        val result = testSubject.suggest(serverType, domain)
+
+        assertThat(result).isEqualTo("smtp.example.org")
+    }
+}
diff --git a/feature/account/oauth/src/test/kotlin/app/k9mail/feature/account/oauth/ui/AccountOAuthStateTest.kt b/feature/account/oauth/src/test/kotlin/app/k9mail/feature/account/oauth/ui/AccountOAuthStateTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c68afbf0792a389786d2f54bc4d271abec1c9f96
--- /dev/null
+++ b/feature/account/oauth/src/test/kotlin/app/k9mail/feature/account/oauth/ui/AccountOAuthStateTest.kt
@@ -0,0 +1,30 @@
+package app.k9mail.feature.account.oauth.ui
+
+import app.k9mail.feature.account.common.ui.WizardNavigationBarState
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract.State
+import assertk.all
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.prop
+import org.junit.Test
+
+class AccountOAuthStateTest {
+
+    @Test
+    fun `should set default values`() {
+        val state = State()
+
+        assertThat(state).all {
+            prop(State::hostname).isEqualTo("")
+            prop(State::emailAddress).isEqualTo("")
+            prop(State::wizardNavigationBarState).isEqualTo(
+                WizardNavigationBarState(
+                    isNextEnabled = false,
+                ),
+            )
+            prop(State::isGoogleSignIn).isEqualTo(false)
+            prop(State::error).isEqualTo(null)
+            prop(State::isLoading).isEqualTo(false)
+        }
+    }
+}
diff --git a/feature/account/oauth/src/test/kotlin/app/k9mail/feature/account/oauth/ui/AccountOAuthViewKtTest.kt b/feature/account/oauth/src/test/kotlin/app/k9mail/feature/account/oauth/ui/AccountOAuthViewKtTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..948dea338111ae208867752700dc44e692e7720b
--- /dev/null
+++ b/feature/account/oauth/src/test/kotlin/app/k9mail/feature/account/oauth/ui/AccountOAuthViewKtTest.kt
@@ -0,0 +1,44 @@
+package app.k9mail.feature.account.oauth.ui
+
+import app.k9mail.core.ui.compose.testing.ComposeTest
+import app.k9mail.core.ui.compose.testing.setContent
+import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
+import app.k9mail.feature.account.oauth.domain.entity.AuthorizationState
+import app.k9mail.feature.account.oauth.domain.entity.OAuthResult
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract.Effect
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract.State
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.isNull
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+class AccountOAuthViewKtTest : ComposeTest() {
+
+    @Test
+    fun `should delegate navigation effects`() = runTest {
+        val initialState = State()
+        val viewModel = FakeAccountOAuthViewModel(initialState)
+        var oAuthResult: OAuthResult? = null
+        val authorizationState = AuthorizationState()
+
+        setContent {
+            ThunderbirdTheme {
+                AccountOAuthView(
+                    onOAuthResult = { oAuthResult = it },
+                    viewModel = viewModel,
+                )
+            }
+        }
+
+        assertThat(oAuthResult).isNull()
+
+        viewModel.effect(Effect.NavigateNext(authorizationState))
+
+        assertThat(oAuthResult).isEqualTo(OAuthResult.Success(authorizationState))
+
+        viewModel.effect(Effect.NavigateBack)
+
+        assertThat(oAuthResult).isEqualTo(OAuthResult.Failure)
+    }
+}
diff --git a/feature/account/oauth/src/test/kotlin/app/k9mail/feature/account/oauth/ui/AccountOAuthViewModelTest.kt b/feature/account/oauth/src/test/kotlin/app/k9mail/feature/account/oauth/ui/AccountOAuthViewModelTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..5b02d150fba618d7c2247960d7ca41dda440ca71
--- /dev/null
+++ b/feature/account/oauth/src/test/kotlin/app/k9mail/feature/account/oauth/ui/AccountOAuthViewModelTest.kt
@@ -0,0 +1,383 @@
+package app.k9mail.feature.account.oauth.ui
+
+import android.app.Activity
+import android.content.Intent
+import app.cash.turbine.testIn
+import app.k9mail.core.ui.compose.testing.MainDispatcherRule
+import app.k9mail.feature.account.oauth.domain.entity.AuthorizationIntentResult
+import app.k9mail.feature.account.oauth.domain.entity.AuthorizationResult
+import app.k9mail.feature.account.oauth.domain.entity.AuthorizationState
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract.Effect
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract.Error
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract.Event
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract.State
+import assertk.assertThat
+import assertk.assertions.assertThatAndTurbinesConsumed
+import assertk.assertions.isEqualTo
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.test.runTest
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+@RunWith(RobolectricTestRunner::class)
+class AccountOAuthViewModelTest {
+
+    @get:Rule
+    val mainDispatcherRule = MainDispatcherRule()
+
+    @Test
+    fun `should change state when google hostname found on initState`() = runTest {
+        val testSubject = createTestSubject(
+            isGoogleSignIn = true,
+        )
+
+        val stateTurbine = testSubject.state.testIn(backgroundScope)
+        val effectTurbine = testSubject.effect.testIn(backgroundScope)
+        val turbines = listOf(stateTurbine, effectTurbine)
+
+        assertThatAndTurbinesConsumed(
+            actual = stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(State())
+        }
+
+        testSubject.initState(defaultState)
+
+        assertThatAndTurbinesConsumed(
+            actual = stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(defaultState.copy(isGoogleSignIn = true))
+        }
+    }
+
+    @Test
+    fun `should not change state when no google hostname found on initState`() = runTest {
+        val testSubject = createTestSubject(
+            isGoogleSignIn = false,
+        )
+
+        val stateTurbine = testSubject.state.testIn(backgroundScope)
+        val effectTurbine = testSubject.effect.testIn(backgroundScope)
+        val turbines = listOf(stateTurbine, effectTurbine)
+
+        assertThatAndTurbinesConsumed(
+            actual = stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(State())
+        }
+
+        testSubject.initState(defaultState)
+
+        assertThatAndTurbinesConsumed(
+            actual = stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(defaultState.copy(isGoogleSignIn = false))
+        }
+    }
+
+    @Test
+    fun `should launch OAuth when SignInClicked event received`() = runTest {
+        val initialState = defaultState
+        val testSubject = createTestSubject(initialState = initialState)
+        val stateTurbine = testSubject.state.testIn(backgroundScope)
+        val effectTurbine = testSubject.effect.testIn(backgroundScope)
+        val turbines = listOf(stateTurbine, effectTurbine)
+
+        assertThatAndTurbinesConsumed(
+            actual = stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(initialState)
+        }
+
+        testSubject.event(Event.SignInClicked)
+
+        assertThatAndTurbinesConsumed(
+            actual = effectTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(Effect.LaunchOAuth(intent))
+        }
+    }
+
+    @Test
+    fun `should show error when SignInClicked event received and OAuth is not supported`() = runTest {
+        val initialState = defaultState
+        val testSubject = createTestSubject(
+            authorizationIntentResult = AuthorizationIntentResult.NotSupported,
+            initialState = initialState,
+        )
+
+        val stateTurbine = testSubject.state.testIn(backgroundScope)
+        val effectTurbine = testSubject.effect.testIn(backgroundScope)
+        val turbines = listOf(stateTurbine, effectTurbine)
+
+        assertThatAndTurbinesConsumed(
+            actual = stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(initialState)
+        }
+
+        testSubject.event(Event.SignInClicked)
+
+        assertThatAndTurbinesConsumed(
+            actual = stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(initialState.copy(error = Error.NotSupported))
+        }
+    }
+
+    @Test
+    fun `should remove error and launch OAuth when OnRetryClicked event received`() = runTest {
+        val initialState = defaultState.copy(
+            error = Error.NotSupported,
+        )
+        val testSubject = createTestSubject(initialState = initialState)
+        val stateTurbine = testSubject.state.testIn(backgroundScope)
+        val effectTurbine = testSubject.effect.testIn(backgroundScope)
+        val turbines = listOf(stateTurbine, effectTurbine)
+
+        assertThatAndTurbinesConsumed(
+            actual = stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(initialState)
+        }
+
+        testSubject.event(Event.OnRetryClicked)
+
+        assertThat(stateTurbine.awaitItem()).isEqualTo(
+            initialState.copy(error = null),
+        )
+
+        assertThatAndTurbinesConsumed(
+            actual = effectTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(Effect.LaunchOAuth(intent))
+        }
+    }
+
+    @Test
+    fun `should finish OAuth sign in when onOAuthResult received with success`() = runTest {
+        val initialState = defaultState
+        val authorizationState = AuthorizationState(state = "state")
+        val testSubject = createTestSubject(
+            authorizationResult = AuthorizationResult.Success(authorizationState),
+            initialState = initialState,
+        )
+        val stateTurbine = testSubject.state.testIn(backgroundScope)
+        val effectTurbine = testSubject.effect.testIn(backgroundScope)
+        val turbines = listOf(stateTurbine, effectTurbine)
+
+        assertThatAndTurbinesConsumed(
+            actual = stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(initialState)
+        }
+
+        testSubject.event(Event.OnOAuthResult(resultCode = Activity.RESULT_OK, data = intent))
+
+        val loadingState = initialState.copy(isLoading = true)
+
+        assertThatAndTurbinesConsumed(
+            actual = stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(loadingState)
+        }
+
+        val successState = loadingState.copy(
+            isLoading = false,
+        )
+
+        assertThat(stateTurbine.awaitItem()).isEqualTo(successState)
+
+        assertThatAndTurbinesConsumed(
+            actual = effectTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(Effect.NavigateNext(authorizationState))
+        }
+    }
+
+    @Test
+    fun `should set error state when onOAuthResult received with canceled`() = runTest {
+        val initialState = defaultState
+        val testSubject = createTestSubject(
+            authorizationResult = AuthorizationResult.Canceled,
+            initialState = initialState,
+        )
+        val stateTurbine = testSubject.state.testIn(backgroundScope)
+        val effectTurbine = testSubject.effect.testIn(backgroundScope)
+        val turbines = listOf(stateTurbine, effectTurbine)
+
+        assertThatAndTurbinesConsumed(
+            actual = stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(initialState)
+        }
+
+        testSubject.event(Event.OnOAuthResult(resultCode = Activity.RESULT_CANCELED, data = intent))
+
+        val failureState = initialState.copy(
+            error = Error.Canceled,
+        )
+
+        assertThatAndTurbinesConsumed(
+            actual = stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(failureState)
+        }
+    }
+
+    @Test
+    fun `should finish OAuth sign in when onOAuthResult received with success but authorization result is cancelled`() =
+        runTest {
+            val initialState = defaultState
+            val testSubject = createTestSubject(
+                authorizationResult = AuthorizationResult.Canceled,
+                initialState = initialState,
+            )
+            val stateTurbine = testSubject.state.testIn(backgroundScope)
+            val effectTurbine = testSubject.effect.testIn(backgroundScope)
+            val turbines = listOf(stateTurbine, effectTurbine)
+
+            assertThatAndTurbinesConsumed(
+                actual = stateTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(initialState)
+            }
+
+            testSubject.event(Event.OnOAuthResult(resultCode = Activity.RESULT_OK, data = intent))
+
+            val loadingState = initialState.copy(isLoading = true)
+
+            assertThatAndTurbinesConsumed(
+                actual = stateTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(loadingState)
+            }
+
+            val failureState = loadingState.copy(
+                isLoading = false,
+                error = Error.Canceled,
+            )
+
+            assertThatAndTurbinesConsumed(
+                actual = stateTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(failureState)
+            }
+        }
+
+    @Test
+    fun `should finish OAuth sign in when onOAuthResult received with success but authorization result is failure`() =
+        runTest {
+            val initialState = defaultState
+            val failure = Exception("failure")
+            val testSubject = createTestSubject(
+                authorizationResult = AuthorizationResult.Failure(failure),
+                initialState = initialState,
+            )
+            val stateTurbine = testSubject.state.testIn(backgroundScope)
+            val effectTurbine = testSubject.effect.testIn(backgroundScope)
+            val turbines = listOf(stateTurbine, effectTurbine)
+
+            assertThatAndTurbinesConsumed(
+                actual = stateTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(initialState)
+            }
+
+            testSubject.event(Event.OnOAuthResult(resultCode = Activity.RESULT_OK, data = intent))
+
+            val loadingState = initialState.copy(isLoading = true)
+
+            assertThatAndTurbinesConsumed(
+                actual = stateTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(loadingState)
+            }
+
+            val failureState = loadingState.copy(
+                isLoading = false,
+                error = Error.Unknown(failure),
+            )
+
+            assertThatAndTurbinesConsumed(
+                actual = stateTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(failureState)
+            }
+        }
+
+    @Test
+    fun `should emit NavigateBack effect when OnBackClicked event received`() = runTest {
+        val viewModel = createTestSubject()
+        val stateTurbine = viewModel.state.testIn(backgroundScope)
+        val effectTurbine = viewModel.effect.testIn(backgroundScope)
+        val turbines = listOf(stateTurbine, effectTurbine)
+
+        assertThatAndTurbinesConsumed(
+            actual = stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(State())
+        }
+
+        viewModel.event(Event.OnBackClicked)
+
+        assertThatAndTurbinesConsumed(
+            actual = effectTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(Effect.NavigateBack)
+        }
+    }
+
+    private companion object {
+        val defaultState = State(
+            hostname = "example.com",
+            emailAddress = "test@example.com",
+        )
+
+        val intent = Intent()
+
+        fun createTestSubject(
+            authorizationIntentResult: AuthorizationIntentResult = AuthorizationIntentResult.Success(intent = intent),
+            authorizationResult: AuthorizationResult = AuthorizationResult.Success(AuthorizationState()),
+            isGoogleSignIn: Boolean = false,
+            initialState: State = State(),
+        ) = AccountOAuthViewModel(
+            getOAuthRequestIntent = { _, _ ->
+                authorizationIntentResult
+            },
+            finishOAuthSignIn = { _ ->
+                delay(50)
+                authorizationResult
+            },
+            checkIsGoogleSignIn = { _ ->
+                isGoogleSignIn
+            },
+            initialState = initialState,
+        )
+    }
+}
diff --git a/feature/account/oauth/src/test/kotlin/app/k9mail/feature/account/oauth/ui/FakeAccountOAuthViewModel.kt b/feature/account/oauth/src/test/kotlin/app/k9mail/feature/account/oauth/ui/FakeAccountOAuthViewModel.kt
new file mode 100644
index 0000000000000000000000000000000000000000..36a06a21fd95d27e1caf2fb6132833dc07c80114
--- /dev/null
+++ b/feature/account/oauth/src/test/kotlin/app/k9mail/feature/account/oauth/ui/FakeAccountOAuthViewModel.kt
@@ -0,0 +1,26 @@
+package app.k9mail.feature.account.oauth.ui
+
+import app.k9mail.core.ui.compose.common.mvi.BaseViewModel
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract.Effect
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract.Event
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract.State
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract.ViewModel
+
+class FakeAccountOAuthViewModel(
+    initialState: State = State(),
+) : BaseViewModel<State, Event, Effect>(initialState), ViewModel {
+
+    val events = mutableListOf<Event>()
+
+    override fun initState(state: State) {
+        updateState { state }
+    }
+
+    override fun event(event: Event) {
+        events.add(event)
+    }
+
+    fun effect(effect: Effect) {
+        emitEffect(effect)
+    }
+}
diff --git a/feature/account/setup/build.gradle.kts b/feature/account/setup/build.gradle.kts
index a0758baa90d4b67c4ab973d41ed75b4414eceef0..fbe8659767747b1ba60995071a512956da7a30ab 100644
--- a/feature/account/setup/build.gradle.kts
+++ b/feature/account/setup/build.gradle.kts
@@ -5,8 +5,28 @@ plugins {
 android {
     namespace = "app.k9mail.feature.account.setup"
     resourcePrefix = "account_setup_"
+
+    buildTypes {
+        debug {
+            manifestPlaceholders["appAuthRedirectScheme"] = "FIXME: override this in your app project"
+        }
+        release {
+            manifestPlaceholders["appAuthRedirectScheme"] = "FIXME: override this in your app project"
+        }
+    }
 }
 
 dependencies {
     implementation(projects.core.ui.compose.designsystem)
+    implementation(projects.core.common)
+    implementation(projects.mail.common)
+    implementation(projects.mail.protocols.imap)
+    implementation(projects.mail.protocols.pop3)
+    implementation(projects.mail.protocols.smtp)
+
+    implementation(projects.feature.autodiscovery.service)
+    implementation(projects.feature.account.common)
+    implementation(projects.feature.account.oauth)
+
+    testImplementation(projects.core.ui.compose.testing)
 }
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/AccountSetupExternalContract.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/AccountSetupExternalContract.kt
new file mode 100644
index 0000000000000000000000000000000000000000..768153f0685fa1433e72e79cc38a32fb665c6636
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/AccountSetupExternalContract.kt
@@ -0,0 +1,19 @@
+package app.k9mail.feature.account.setup
+
+import app.k9mail.feature.account.setup.domain.entity.Account
+
+interface AccountSetupExternalContract {
+
+    fun interface AccountCreator {
+        suspend fun createAccount(account: Account): AccountCreatorResult
+
+        sealed interface AccountCreatorResult {
+            data class Success(val accountUuid: String) : AccountCreatorResult
+            data class Error(val message: String) : AccountCreatorResult
+        }
+    }
+
+    fun interface AccountOwnerNameProvider {
+        suspend fun getOwnerName(): String?
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/AccountSetupModule.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/AccountSetupModule.kt
new file mode 100644
index 0000000000000000000000000000000000000000..0a1de6b030f6c4b403765170bbfc3f811f140ff9
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/AccountSetupModule.kt
@@ -0,0 +1,162 @@
+package app.k9mail.feature.account.setup
+
+import app.k9mail.autodiscovery.api.AutoDiscoveryService
+import app.k9mail.autodiscovery.service.RealAutoDiscoveryService
+import app.k9mail.core.common.coreCommonModule
+import app.k9mail.feature.account.oauth.featureAccountOAuthModule
+import app.k9mail.feature.account.setup.data.InMemoryAccountSetupStateRepository
+import app.k9mail.feature.account.setup.data.InMemoryCertificateErrorRepository
+import app.k9mail.feature.account.setup.domain.DomainContract
+import app.k9mail.feature.account.setup.domain.usecase.AddServerCertificateException
+import app.k9mail.feature.account.setup.domain.usecase.CreateAccount
+import app.k9mail.feature.account.setup.domain.usecase.GetAutoDiscovery
+import app.k9mail.feature.account.setup.domain.usecase.ValidateServerSettings
+import app.k9mail.feature.account.setup.ui.AccountSetupViewModel
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryValidator
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryViewModel
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigValidator
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigViewModel
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsValidator
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsViewModel
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigValidator
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigViewModel
+import app.k9mail.feature.account.setup.ui.servercertificate.CertificateErrorViewModel
+import app.k9mail.feature.account.setup.ui.validation.AccountValidationViewModel
+import com.fsck.k9.mail.oauth.AuthStateStorage
+import com.fsck.k9.mail.store.imap.ImapServerSettingsValidator
+import com.fsck.k9.mail.store.pop3.Pop3ServerSettingsValidator
+import com.fsck.k9.mail.transport.smtp.SmtpServerSettingsValidator
+import okhttp3.OkHttpClient
+import org.koin.androidx.viewmodel.dsl.viewModel
+import org.koin.core.module.Module
+import org.koin.core.qualifier.named
+import org.koin.dsl.binds
+import org.koin.dsl.module
+
+val featureAccountSetupModule: Module = module {
+    includes(coreCommonModule, featureAccountOAuthModule)
+
+    single<OkHttpClient> {
+        OkHttpClient()
+    }
+
+    single<AutoDiscoveryService> {
+        RealAutoDiscoveryService(
+            okHttpClient = get(),
+        )
+    }
+
+    single<DomainContract.UseCase.GetAutoDiscovery> {
+        GetAutoDiscovery(
+            service = get(),
+            oauthProvider = get(),
+        )
+    }
+
+    single {
+        InMemoryAccountSetupStateRepository()
+    }.binds(arrayOf(DomainContract.AccountSetupStateRepository::class, AuthStateStorage::class))
+
+    single<DomainContract.CertificateErrorRepository> { InMemoryCertificateErrorRepository() }
+
+    factory<DomainContract.UseCase.ValidateServerSettings> {
+        ValidateServerSettings(
+            authStateStorage = get(),
+            imapValidator = ImapServerSettingsValidator(
+                trustedSocketFactory = get(),
+                oAuth2TokenProviderFactory = get(),
+                clientIdAppName = "null",
+            ),
+            pop3Validator = Pop3ServerSettingsValidator(
+                trustedSocketFactory = get(),
+            ),
+            smtpValidator = SmtpServerSettingsValidator(
+                trustedSocketFactory = get(),
+                oAuth2TokenProviderFactory = get(),
+            ),
+        )
+    }
+
+    factory<DomainContract.UseCase.AddServerCertificateException> {
+        AddServerCertificateException(
+            localKeyStore = get(),
+        )
+    }
+
+    factory<DomainContract.UseCase.CreateAccount> {
+        CreateAccount(
+            accountCreator = get(),
+        )
+    }
+
+    factory<AccountAutoDiscoveryContract.Validator> { AccountAutoDiscoveryValidator() }
+    factory<AccountIncomingConfigContract.Validator> { AccountIncomingConfigValidator() }
+    factory<AccountOutgoingConfigContract.Validator> { AccountOutgoingConfigValidator() }
+    factory<AccountOptionsContract.Validator> { AccountOptionsValidator() }
+
+    viewModel {
+        AccountSetupViewModel(
+            createAccount = get(),
+            accountSetupStateRepository = get(),
+        )
+    }
+    viewModel {
+        AccountAutoDiscoveryViewModel(
+            validator = get(),
+            getAutoDiscovery = get(),
+            accountSetupStateRepository = get(),
+            oAuthViewModel = get(),
+        )
+    }
+    viewModel {
+        AccountIncomingConfigViewModel(
+            validator = get(),
+            accountSetupStateRepository = get(),
+        )
+    }
+    viewModel(named(NAME_INCOMING_VALIDATION)) {
+        AccountValidationViewModel(
+            validateServerSettings = get(),
+            accountSetupStateRepository = get(),
+            authorizationStateRepository = get(),
+            certificateErrorRepository = get(),
+            oAuthViewModel = get(),
+            isIncomingValidation = true,
+        )
+    }
+    viewModel {
+        AccountOutgoingConfigViewModel(
+            validator = get(),
+            accountSetupStateRepository = get(),
+        )
+    }
+    viewModel(named(NAME_OUTGOING_VALIDATION)) {
+        AccountValidationViewModel(
+            validateServerSettings = get(),
+            accountSetupStateRepository = get(),
+            authorizationStateRepository = get(),
+            certificateErrorRepository = get(),
+            oAuthViewModel = get(),
+            isIncomingValidation = false,
+        )
+    }
+    viewModel {
+        AccountOptionsViewModel(
+            validator = get(),
+            accountSetupStateRepository = get(),
+        )
+    }
+    viewModel {
+        CertificateErrorViewModel(
+            certificateErrorRepository = get(),
+            addServerCertificateException = get(),
+        )
+    }
+}
+
+internal const val NAME_INCOMING_VALIDATION = "incoming_validation"
+internal const val NAME_OUTGOING_VALIDATION = "outgoing_validation"
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/data/InMemoryAccountSetupStateRepository.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/data/InMemoryAccountSetupStateRepository.kt
new file mode 100644
index 0000000000000000000000000000000000000000..fa1cea0b561009bd4fdba90329d226b550f08031
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/data/InMemoryAccountSetupStateRepository.kt
@@ -0,0 +1,57 @@
+package app.k9mail.feature.account.setup.data
+
+import app.k9mail.feature.account.oauth.domain.entity.AuthorizationState
+import app.k9mail.feature.account.setup.domain.DomainContract
+import app.k9mail.feature.account.setup.domain.entity.AccountOptions
+import app.k9mail.feature.account.setup.domain.entity.AccountSetupState
+import com.fsck.k9.mail.ServerSettings
+import com.fsck.k9.mail.oauth.AuthStateStorage
+
+class InMemoryAccountSetupStateRepository(
+    private var state: AccountSetupState = AccountSetupState(),
+) : DomainContract.AccountSetupStateRepository, AuthStateStorage {
+
+    override fun getState(): AccountSetupState {
+        return state
+    }
+
+    override fun save(accountSetupState: AccountSetupState) {
+        state = accountSetupState
+    }
+
+    override fun saveEmailAddress(emailAddress: String) {
+        state = state.copy(emailAddress = emailAddress)
+    }
+
+    override fun saveIncomingServerSettings(serverSettings: ServerSettings) {
+        state = state.copy(incomingServerSettings = serverSettings)
+    }
+
+    override fun saveOutgoingServerSettings(serverSettings: ServerSettings) {
+        state = state.copy(outgoingServerSettings = serverSettings)
+    }
+
+    override fun saveAuthorizationState(authorizationState: AuthorizationState) {
+        state = state.copy(authorizationState = authorizationState)
+    }
+
+    override fun getEmail(): String? {
+        return state.emailAddress
+    }
+
+    override fun saveOptions(options: AccountOptions) {
+        state = state.copy(options = options)
+    }
+
+    override fun clear() {
+        state = AccountSetupState()
+    }
+
+    override fun getAuthorizationState(): String? {
+        return state.authorizationState?.state
+    }
+
+    override fun updateAuthorizationState(authorizationState: String?) {
+        state = state.copy(authorizationState = AuthorizationState(authorizationState))
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/data/InMemoryCertificateErrorRepository.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/data/InMemoryCertificateErrorRepository.kt
new file mode 100644
index 0000000000000000000000000000000000000000..834ec8007dd2d122efaee993640c598fe68d73d1
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/data/InMemoryCertificateErrorRepository.kt
@@ -0,0 +1,21 @@
+package app.k9mail.feature.account.setup.data
+
+import app.k9mail.feature.account.setup.domain.DomainContract
+import app.k9mail.feature.account.setup.domain.entity.CertificateError
+
+class InMemoryCertificateErrorRepository(
+    private var certificateError: CertificateError? = null,
+) : DomainContract.CertificateErrorRepository {
+
+    override fun getCertificateError(): CertificateError? {
+        return certificateError
+    }
+
+    override fun setCertificateError(certificateError: CertificateError) {
+        this.certificateError = certificateError
+    }
+
+    override fun clearCertificateError() {
+        certificateError = null
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/AutoDiscoveryMapper.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/AutoDiscoveryMapper.kt
new file mode 100644
index 0000000000000000000000000000000000000000..cc99e9eee3ab96ee881e5bd9126b9ea4446017be
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/AutoDiscoveryMapper.kt
@@ -0,0 +1,58 @@
+package app.k9mail.feature.account.setup.domain
+
+import app.k9mail.autodiscovery.api.ImapServerSettings
+import app.k9mail.autodiscovery.api.IncomingServerSettings
+import app.k9mail.autodiscovery.api.OutgoingServerSettings
+import app.k9mail.autodiscovery.api.SmtpServerSettings
+import app.k9mail.feature.account.setup.domain.entity.toAuthType
+import app.k9mail.feature.account.setup.domain.entity.toAuthenticationType
+import app.k9mail.feature.account.setup.domain.entity.toConnectionSecurity
+import app.k9mail.feature.account.setup.domain.entity.toMailConnectionSecurity
+import com.fsck.k9.mail.ServerSettings
+
+internal fun IncomingServerSettings.toServerSettings(password: String?): ServerSettings {
+    return when (this) {
+        is ImapServerSettings -> this.toImapServerSettings(password)
+        else -> throw IllegalArgumentException("Unknown server settings type: $this")
+    }
+}
+
+private fun ImapServerSettings.toImapServerSettings(password: String?): ServerSettings {
+    return ServerSettings(
+        type = "imap",
+        host = hostname.value,
+        port = port.value,
+        connectionSecurity = connectionSecurity.toConnectionSecurity().toMailConnectionSecurity(),
+        authenticationType = authenticationTypes.first().toAuthenticationType().toAuthType(),
+        username = username,
+        password = password,
+        clientCertificateAlias = null,
+        extra = emptyMap(),
+    )
+}
+
+/**
+ * Convert [OutgoingServerSettings] to [ServerSettings].
+ *
+ * @throws IllegalArgumentException if the server settings type is unknown.
+ */
+internal fun OutgoingServerSettings.toServerSettings(password: String?): ServerSettings {
+    return when (this) {
+        is SmtpServerSettings -> this.toSmtpServerSettings(password)
+        else -> throw IllegalArgumentException("Unknown server settings type: $this")
+    }
+}
+
+private fun SmtpServerSettings.toSmtpServerSettings(password: String?): ServerSettings {
+    return ServerSettings(
+        type = "smtp",
+        host = hostname.value,
+        port = port.value,
+        connectionSecurity = connectionSecurity.toConnectionSecurity().toMailConnectionSecurity(),
+        authenticationType = authenticationTypes.first().toAuthenticationType().toAuthType(),
+        username = username,
+        password = password,
+        clientCertificateAlias = null,
+        extra = emptyMap(),
+    )
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/DomainContract.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/DomainContract.kt
new file mode 100644
index 0000000000000000000000000000000000000000..e795f149b7b596480117cd0b59da8f72155bedd7
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/DomainContract.kt
@@ -0,0 +1,104 @@
+package app.k9mail.feature.account.setup.domain
+
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.oauth.domain.entity.AuthorizationState
+import app.k9mail.feature.account.setup.domain.entity.AccountOptions
+import app.k9mail.feature.account.setup.domain.entity.AccountSetupState
+import app.k9mail.feature.account.setup.domain.entity.CertificateError
+import com.fsck.k9.mail.ServerSettings
+import com.fsck.k9.mail.server.ServerSettingsValidationResult
+import java.security.cert.X509Certificate
+
+interface DomainContract {
+
+    interface AccountSetupStateRepository {
+        fun getState(): AccountSetupState
+
+        fun save(accountSetupState: AccountSetupState)
+
+        fun saveEmailAddress(emailAddress: String)
+
+        fun saveIncomingServerSettings(serverSettings: ServerSettings)
+
+        fun saveOutgoingServerSettings(serverSettings: ServerSettings)
+
+        fun saveAuthorizationState(authorizationState: AuthorizationState)
+
+        fun saveOptions(options: AccountOptions)
+
+        fun clear()
+    }
+
+    interface CertificateErrorRepository {
+        fun getCertificateError(): CertificateError?
+
+        fun setCertificateError(certificateError: CertificateError)
+
+        fun clearCertificateError()
+    }
+
+    interface UseCase {
+        fun interface GetAutoDiscovery {
+            suspend fun execute(emailAddress: String): AutoDiscoveryResult
+        }
+
+        fun interface ValidateServerSettings {
+            suspend fun execute(settings: ServerSettings): ServerSettingsValidationResult
+        }
+
+        fun interface AddServerCertificateException {
+            suspend fun addCertificate(hostname: String, port: Int, certificate: X509Certificate?)
+        }
+
+        fun interface CreateAccount {
+            suspend fun execute(
+                emailAddress: String,
+                incomingServerSettings: ServerSettings,
+                outgoingServerSettings: ServerSettings,
+                authorizationState: String?,
+                options: AccountOptions,
+            ): String
+        }
+
+        fun interface ValidateEmailAddress {
+            fun execute(emailAddress: String): ValidationResult
+        }
+
+        fun interface ValidatePassword {
+            fun execute(password: String): ValidationResult
+        }
+
+        fun interface ValidateConfigurationApproval {
+            fun execute(isApproved: Boolean?, isAutoDiscoveryTrusted: Boolean?): ValidationResult
+        }
+
+        fun interface ValidateServer {
+            fun execute(server: String): ValidationResult
+        }
+
+        fun interface ValidatePort {
+            fun execute(port: Long?): ValidationResult
+        }
+
+        fun interface ValidateUsername {
+            fun execute(username: String): ValidationResult
+        }
+
+        fun interface ValidateImapPrefix {
+            fun execute(imapPrefix: String): ValidationResult
+        }
+
+        fun interface ValidateAccountName {
+            fun execute(accountName: String): ValidationResult
+        }
+
+        fun interface ValidateDisplayName {
+            fun execute(displayName: String): ValidationResult
+        }
+
+        fun interface ValidateEmailSignature {
+            fun execute(emailSignature: String): ValidationResult
+        }
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/Account.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/Account.kt
new file mode 100644
index 0000000000000000000000000000000000000000..0edc11e48034bcc9d26b84a6609c7e04689d664b
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/Account.kt
@@ -0,0 +1,11 @@
+package app.k9mail.feature.account.setup.domain.entity
+
+import com.fsck.k9.mail.ServerSettings
+
+data class Account(
+    val emailAddress: String,
+    val incomingServerSettings: ServerSettings,
+    val outgoingServerSettings: ServerSettings,
+    val authorizationState: String?,
+    val options: AccountOptions,
+)
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/AccountOptions.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/AccountOptions.kt
new file mode 100644
index 0000000000000000000000000000000000000000..403af527ac341c63cf540db266b399730514ce7e
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/AccountOptions.kt
@@ -0,0 +1,10 @@
+package app.k9mail.feature.account.setup.domain.entity
+
+data class AccountOptions(
+    val accountName: String,
+    val displayName: String,
+    val emailSignature: String?,
+    val checkFrequencyInMinutes: Int,
+    val messageDisplayCount: Int,
+    val showNotification: Boolean,
+)
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/AccountSetupState.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/AccountSetupState.kt
new file mode 100644
index 0000000000000000000000000000000000000000..db9cd1431e6bdab2983cb2ca3f6342d4cac8ef95
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/AccountSetupState.kt
@@ -0,0 +1,12 @@
+package app.k9mail.feature.account.setup.domain.entity
+
+import app.k9mail.feature.account.oauth.domain.entity.AuthorizationState
+import com.fsck.k9.mail.ServerSettings
+
+data class AccountSetupState(
+    val emailAddress: String? = null,
+    val incomingServerSettings: ServerSettings? = null,
+    val outgoingServerSettings: ServerSettings? = null,
+    val authorizationState: AuthorizationState? = null,
+    val options: AccountOptions? = null,
+)
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/AuthenticationType.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/AuthenticationType.kt
new file mode 100644
index 0000000000000000000000000000000000000000..77591f7956f79aefb4c9632a9366de0912a7b22b
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/AuthenticationType.kt
@@ -0,0 +1,58 @@
+package app.k9mail.feature.account.setup.domain.entity
+
+import com.fsck.k9.mail.AuthType
+import kotlinx.collections.immutable.toImmutableList
+
+enum class AuthenticationType(
+    val isUsernameRequired: Boolean,
+    val isPasswordRequired: Boolean,
+) {
+    None(
+        isUsernameRequired = false,
+        isPasswordRequired = false,
+    ),
+    PasswordCleartext(
+        isUsernameRequired = true,
+        isPasswordRequired = true,
+    ),
+    PasswordEncrypted(
+        isUsernameRequired = true,
+        isPasswordRequired = true,
+    ),
+    ClientCertificate(
+        isUsernameRequired = true,
+        isPasswordRequired = false,
+    ),
+    OAuth2(
+        isUsernameRequired = true,
+        isPasswordRequired = false,
+    ),
+    ;
+
+    companion object {
+        val DEFAULT = PasswordCleartext
+        fun all() = values().toList().toImmutableList()
+
+        fun outgoing() = all()
+    }
+}
+
+fun AuthenticationType.toAuthType(): AuthType {
+    return when (this) {
+        AuthenticationType.None -> AuthType.PLAIN
+        AuthenticationType.PasswordCleartext -> AuthType.PLAIN
+        AuthenticationType.PasswordEncrypted -> AuthType.CRAM_MD5
+        AuthenticationType.ClientCertificate -> AuthType.EXTERNAL
+        AuthenticationType.OAuth2 -> AuthType.XOAUTH2
+    }
+}
+
+fun AuthType.toAuthenticationType(): AuthenticationType {
+    return when (this) {
+        AuthType.PLAIN -> AuthenticationType.PasswordCleartext
+        AuthType.CRAM_MD5 -> AuthenticationType.PasswordEncrypted
+        AuthType.EXTERNAL -> AuthenticationType.ClientCertificate
+        AuthType.XOAUTH2 -> AuthenticationType.OAuth2
+        else -> AuthenticationType.None
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/AutoDiscoveryAuthenticationType.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/AutoDiscoveryAuthenticationType.kt
new file mode 100644
index 0000000000000000000000000000000000000000..a6c2e0be7ed30daf76fa17bd786c867fef555564
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/AutoDiscoveryAuthenticationType.kt
@@ -0,0 +1,11 @@
+package app.k9mail.feature.account.setup.domain.entity
+
+typealias AutoDiscoveryAuthenticationType = app.k9mail.autodiscovery.api.AuthenticationType
+
+internal fun AutoDiscoveryAuthenticationType.toAuthenticationType(): AuthenticationType {
+    return when (this) {
+        AutoDiscoveryAuthenticationType.PasswordCleartext -> AuthenticationType.PasswordCleartext
+        AutoDiscoveryAuthenticationType.PasswordEncrypted -> AuthenticationType.PasswordEncrypted
+        AutoDiscoveryAuthenticationType.OAuth2 -> AuthenticationType.OAuth2
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/AutoDiscoveryConnectionSecurity.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/AutoDiscoveryConnectionSecurity.kt
new file mode 100644
index 0000000000000000000000000000000000000000..8405582849cc36791aea54b9910617df88ca5b44
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/AutoDiscoveryConnectionSecurity.kt
@@ -0,0 +1,10 @@
+package app.k9mail.feature.account.setup.domain.entity
+
+internal typealias AutoDiscoveryConnectionSecurity = app.k9mail.autodiscovery.api.ConnectionSecurity
+
+internal fun AutoDiscoveryConnectionSecurity.toConnectionSecurity(): ConnectionSecurity {
+    return when (this) {
+        AutoDiscoveryConnectionSecurity.StartTLS -> ConnectionSecurity.StartTLS
+        AutoDiscoveryConnectionSecurity.TLS -> ConnectionSecurity.TLS
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/CertificateError.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/CertificateError.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d85b7a0052089cb8718ae9de8be5192c1de78b4e
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/CertificateError.kt
@@ -0,0 +1,9 @@
+package app.k9mail.feature.account.setup.domain.entity
+
+import java.security.cert.X509Certificate
+
+data class CertificateError(
+    val hostname: String,
+    val port: Int,
+    val certificateChain: List<X509Certificate>,
+)
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/ConnectionSecurity.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/ConnectionSecurity.kt
new file mode 100644
index 0000000000000000000000000000000000000000..beb5f18836d60a45c32aab4b429b3f91b06a6e11
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/ConnectionSecurity.kt
@@ -0,0 +1,61 @@
+package app.k9mail.feature.account.setup.domain.entity
+
+import app.k9mail.feature.account.setup.domain.entity.ConnectionSecurity.None
+import app.k9mail.feature.account.setup.domain.entity.ConnectionSecurity.StartTLS
+import app.k9mail.feature.account.setup.domain.entity.ConnectionSecurity.TLS
+import kotlinx.collections.immutable.toImmutableList
+
+enum class ConnectionSecurity {
+    None,
+    StartTLS,
+    TLS,
+    ;
+
+    companion object {
+        val DEFAULT = TLS
+        fun all() = values().toList().toImmutableList()
+    }
+}
+
+internal fun ConnectionSecurity.toMailConnectionSecurity(): MailConnectionSecurity {
+    return when (this) {
+        None -> MailConnectionSecurity.NONE
+        StartTLS -> MailConnectionSecurity.STARTTLS_REQUIRED
+        TLS -> MailConnectionSecurity.SSL_TLS_REQUIRED
+    }
+}
+
+internal fun MailConnectionSecurity.toConnectionSecurity(): ConnectionSecurity {
+    return when (this) {
+        MailConnectionSecurity.NONE -> None
+        MailConnectionSecurity.STARTTLS_REQUIRED -> StartTLS
+        MailConnectionSecurity.SSL_TLS_REQUIRED -> TLS
+    }
+}
+
+@Suppress("MagicNumber")
+internal fun ConnectionSecurity.toSmtpDefaultPort(): Long {
+    return when (this) {
+        None -> 587
+        StartTLS -> 587
+        TLS -> 465
+    }
+}
+
+@Suppress("MagicNumber")
+internal fun ConnectionSecurity.toImapDefaultPort(): Long {
+    return when (this) {
+        None -> 143
+        StartTLS -> 143
+        TLS -> 993
+    }
+}
+
+@Suppress("MagicNumber")
+internal fun ConnectionSecurity.toPop3DefaultPort(): Long {
+    return when (this) {
+        None -> 110
+        StartTLS -> 110
+        TLS -> 995
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/EmailCheckFrequency.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/EmailCheckFrequency.kt
new file mode 100644
index 0000000000000000000000000000000000000000..729ad8db2019cbcc73fd6f677288d4c59bcc98a7
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/EmailCheckFrequency.kt
@@ -0,0 +1,33 @@
+package app.k9mail.feature.account.setup.domain.entity
+
+import kotlinx.collections.immutable.toImmutableList
+
+@Suppress("MagicNumber")
+enum class EmailCheckFrequency(
+    val minutes: Int,
+) {
+    MANUAL(-1),
+    EVERY_15_MINUTES(15),
+    EVERY_30_MINUTES(30),
+    EVERY_HOUR(1.fromHour()),
+    EVERY_2_HOURS(2.fromHour()),
+    EVERY_3_HOURS(3.fromHour()),
+    EVERY_6_HOURS(6.fromHour()),
+    EVERY_12_HOURS(12.fromHour()),
+    EVERY_24_HOURS(24.fromHour()),
+    ;
+
+    companion object {
+        val DEFAULT = EVERY_HOUR
+        fun all() = values().toList().toImmutableList()
+
+        fun fromMinutes(minutes: Int): EmailCheckFrequency {
+            return all().find { it.minutes == minutes } ?: DEFAULT
+        }
+    }
+}
+
+@Suppress("MagicNumber")
+private fun Int.fromHour(): Int {
+    return 60 * this
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/EmailDisplayCount.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/EmailDisplayCount.kt
new file mode 100644
index 0000000000000000000000000000000000000000..f315ccbfeda5f3c5995ef3197288b592c5809c3f
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/EmailDisplayCount.kt
@@ -0,0 +1,26 @@
+package app.k9mail.feature.account.setup.domain.entity
+
+import kotlinx.collections.immutable.toImmutableList
+
+@Suppress("MagicNumber")
+enum class EmailDisplayCount(
+    val count: Int,
+) {
+    MESSAGES_10(10),
+    MESSAGES_25(25),
+    MESSAGES_50(50),
+    MESSAGES_100(100),
+    MESSAGES_250(250),
+    MESSAGES_500(500),
+    MESSAGES_1000(1000),
+    ;
+
+    companion object {
+        val DEFAULT = MESSAGES_25
+        fun all() = values().toList().toImmutableList()
+
+        fun fromCount(count: Int): EmailDisplayCount {
+            return all().find { it.count == count } ?: DEFAULT
+        }
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/IncomingProtocolType.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/IncomingProtocolType.kt
new file mode 100644
index 0000000000000000000000000000000000000000..cc245cecd2b528437ba9211687c4329b6638dd81
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/IncomingProtocolType.kt
@@ -0,0 +1,29 @@
+package app.k9mail.feature.account.setup.domain.entity
+
+import kotlinx.collections.immutable.toImmutableList
+
+enum class IncomingProtocolType(
+    val defaultName: String,
+    val defaultConnectionSecurity: ConnectionSecurity,
+) {
+    IMAP("imap", ConnectionSecurity.TLS),
+    POP3("pop3", ConnectionSecurity.TLS),
+    ;
+
+    companion object {
+        val DEFAULT = IMAP
+
+        fun all() = values().toList().toImmutableList()
+
+        fun fromName(name: String): IncomingProtocolType {
+            return values().find { it.defaultName == name } ?: throw IllegalArgumentException("Unknown protocol: $name")
+        }
+    }
+}
+
+internal fun IncomingProtocolType.toDefaultPort(connectionSecurity: ConnectionSecurity): Long {
+    return when (this) {
+        IncomingProtocolType.IMAP -> connectionSecurity.toImapDefaultPort()
+        IncomingProtocolType.POP3 -> connectionSecurity.toPop3DefaultPort()
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/IncomingServerSettingsExtension.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/IncomingServerSettingsExtension.kt
new file mode 100644
index 0000000000000000000000000000000000000000..f45819e1ad976090e7b1ea3b28244f3f9ac1a580
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/IncomingServerSettingsExtension.kt
@@ -0,0 +1,11 @@
+package app.k9mail.feature.account.setup.domain.entity
+
+import app.k9mail.autodiscovery.api.ImapServerSettings
+import app.k9mail.autodiscovery.api.IncomingServerSettings
+
+internal fun IncomingServerSettings.toIncomingProtocolType(): IncomingProtocolType {
+    when (this) {
+        is ImapServerSettings -> return IncomingProtocolType.IMAP
+        else -> throw IllegalArgumentException("Unsupported incoming server settings type: $this")
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/MailConnectionSecurity.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/MailConnectionSecurity.kt
new file mode 100644
index 0000000000000000000000000000000000000000..7e4a9efacf5347ae0fc7dc19fc07471c45ba432b
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/MailConnectionSecurity.kt
@@ -0,0 +1,3 @@
+package app.k9mail.feature.account.setup.domain.entity
+
+internal typealias MailConnectionSecurity = com.fsck.k9.mail.ConnectionSecurity
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/OutgoingProtocolType.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/OutgoingProtocolType.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c90cde0aba168b12a6c62e94e0ea0c2839b5f46c
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/OutgoingProtocolType.kt
@@ -0,0 +1,23 @@
+package app.k9mail.feature.account.setup.domain.entity
+
+import kotlinx.collections.immutable.toImmutableList
+
+internal enum class OutgoingProtocolType(
+    val defaultName: String,
+    val defaultConnectionSecurity: ConnectionSecurity,
+) {
+    SMTP("smtp", ConnectionSecurity.TLS),
+    ;
+
+    companion object {
+        val DEFAULT = SMTP
+
+        fun all() = values().toList().toImmutableList()
+    }
+}
+
+internal fun OutgoingProtocolType.toDefaultPort(connectionSecurity: ConnectionSecurity): Long {
+    return when (this) {
+        OutgoingProtocolType.SMTP -> connectionSecurity.toSmtpDefaultPort()
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/ServerSettingsExtension.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/ServerSettingsExtension.kt
new file mode 100644
index 0000000000000000000000000000000000000000..cc4425d19c85e85cfc0eac4f2aa5518211334943
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/entity/ServerSettingsExtension.kt
@@ -0,0 +1,6 @@
+package app.k9mail.feature.account.setup.domain.entity
+
+import com.fsck.k9.mail.AuthType
+import com.fsck.k9.mail.ServerSettings
+
+fun ServerSettings?.isOAuth() = this?.authenticationType == AuthType.XOAUTH2
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/input/BooleanInputField.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/input/BooleanInputField.kt
new file mode 100644
index 0000000000000000000000000000000000000000..561e56257228ef10fe01b8c1577e7dc2faac476a
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/input/BooleanInputField.kt
@@ -0,0 +1,74 @@
+package app.k9mail.feature.account.setup.domain.input
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+
+class BooleanInputField(
+    override val value: Boolean? = null,
+    override val error: ValidationError? = null,
+    override val isValid: Boolean = false,
+) : InputField<Boolean?> {
+    override fun updateValue(value: Boolean?): BooleanInputField {
+        return BooleanInputField(
+            value = value,
+            error = null,
+            isValid = false,
+        )
+    }
+
+    override fun updateError(error: ValidationError?): BooleanInputField {
+        return BooleanInputField(
+            value = value,
+            error = error,
+            isValid = false,
+        )
+    }
+
+    override fun updateValidity(isValid: Boolean): BooleanInputField {
+        if (isValid == this.isValid) return this
+
+        return BooleanInputField(
+            value = value,
+            error = null,
+            isValid = isValid,
+        )
+    }
+
+    override fun updateFromValidationResult(result: ValidationResult): BooleanInputField {
+        return when (result) {
+            is ValidationResult.Success -> BooleanInputField(
+                value = value,
+                error = null,
+                isValid = true,
+            )
+
+            is ValidationResult.Failure -> BooleanInputField(
+                value = value,
+                error = result.error,
+                isValid = false,
+            )
+        }
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as BooleanInputField
+
+        if (value != other.value) return false
+        if (error != other.error) return false
+        return isValid == other.isValid
+    }
+
+    override fun hashCode(): Int {
+        var result = value?.hashCode() ?: 0
+        result = 31 * result + (error?.hashCode() ?: 0)
+        result = 31 * result + isValid.hashCode()
+        return result
+    }
+
+    override fun toString(): String {
+        return "BooleanInputField(value=$value, error=$error, isValid=$isValid)"
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/input/InputField.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/input/InputField.kt
new file mode 100644
index 0000000000000000000000000000000000000000..9aa75019fd3709e4857becc22147511cd015b5d8
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/input/InputField.kt
@@ -0,0 +1,48 @@
+package app.k9mail.feature.account.setup.domain.input
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+
+/**
+ * InputField is an interface defining the state of an input field.
+ *
+ * @param T The type of the value the input field holds.
+ */
+interface InputField<T> {
+    val value: T
+    val error: ValidationError?
+    val isValid: Boolean
+
+    /**
+     * Updates the current value of the input field.
+     *
+     * @param value The new value to be set for the input field.
+     * @return a new InputField instance with the updated value.
+     */
+    fun updateValue(value: T): InputField<T>
+
+    /**
+     * Updates the current error of the input field.
+     *
+     * @param error The new error to be set for the input field.
+     */
+    fun updateError(error: ValidationError?): InputField<T>
+
+    /**
+     * Updates the current validity of the input field.
+     *
+     * @param isValid The new validity to be set for the input field.
+     */
+    fun updateValidity(isValid: Boolean): InputField<T>
+
+    /**
+     * Checks if the input field currently has an error.
+     *
+     * @return a Boolean indicating whether the input field has an error.
+     */
+    fun hasError(): Boolean {
+        return error != null
+    }
+
+    fun updateFromValidationResult(result: ValidationResult): InputField<T>
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/input/NumberInputField.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/input/NumberInputField.kt
new file mode 100644
index 0000000000000000000000000000000000000000..34b8a825133119f27756b206564214c99fff99e5
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/input/NumberInputField.kt
@@ -0,0 +1,75 @@
+package app.k9mail.feature.account.setup.domain.input
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+
+class NumberInputField(
+    override val value: Long? = null,
+    override val error: ValidationError? = null,
+    override val isValid: Boolean = false,
+) : InputField<Long?> {
+
+    override fun updateValue(value: Long?): NumberInputField {
+        return NumberInputField(
+            value = value,
+            error = null,
+            isValid = false,
+        )
+    }
+
+    override fun updateError(error: ValidationError?): NumberInputField {
+        return NumberInputField(
+            value = value,
+            error = error,
+            isValid = false,
+        )
+    }
+
+    override fun updateValidity(isValid: Boolean): NumberInputField {
+        if (isValid == this.isValid) return this
+
+        return NumberInputField(
+            value = value,
+            error = null,
+            isValid = isValid,
+        )
+    }
+
+    override fun updateFromValidationResult(result: ValidationResult): NumberInputField {
+        return when (result) {
+            is ValidationResult.Success -> NumberInputField(
+                value = value,
+                error = null,
+                isValid = true,
+            )
+
+            is ValidationResult.Failure -> NumberInputField(
+                value = value,
+                error = result.error,
+                isValid = false,
+            )
+        }
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as NumberInputField
+
+        if (value != other.value) return false
+        if (error != other.error) return false
+        return isValid == other.isValid
+    }
+
+    override fun hashCode(): Int {
+        var result = value?.hashCode() ?: 0
+        result = 31 * result + (error?.hashCode() ?: 0)
+        result = 31 * result + isValid.hashCode()
+        return result
+    }
+
+    override fun toString(): String {
+        return "NumberInputField(value=$value, error=$error, isValid=$isValid)"
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/input/StringInputField.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/input/StringInputField.kt
new file mode 100644
index 0000000000000000000000000000000000000000..a793eb5320f4b7c348b5425880fe07fd0908e79e
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/input/StringInputField.kt
@@ -0,0 +1,75 @@
+package app.k9mail.feature.account.setup.domain.input
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+
+class StringInputField(
+    override val value: String = "",
+    override val error: ValidationError? = null,
+    override val isValid: Boolean = false,
+) : InputField<String> {
+
+    override fun updateValue(value: String): StringInputField {
+        return StringInputField(
+            value = value,
+            error = null,
+            isValid = false,
+        )
+    }
+
+    override fun updateError(error: ValidationError?): StringInputField {
+        return StringInputField(
+            value = value,
+            error = error,
+            isValid = false,
+        )
+    }
+
+    override fun updateValidity(isValid: Boolean): StringInputField {
+        if (isValid == this.isValid) return this
+
+        return StringInputField(
+            value = value,
+            error = null,
+            isValid = isValid,
+        )
+    }
+
+    override fun updateFromValidationResult(result: ValidationResult): StringInputField {
+        return when (result) {
+            is ValidationResult.Success -> StringInputField(
+                value = value,
+                error = null,
+                isValid = true,
+            )
+
+            is ValidationResult.Failure -> StringInputField(
+                value = value,
+                error = result.error,
+                isValid = false,
+            )
+        }
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as StringInputField
+
+        if (value != other.value) return false
+        if (error != other.error) return false
+        return isValid == other.isValid
+    }
+
+    override fun hashCode(): Int {
+        var result = value.hashCode()
+        result = 31 * result + (error?.hashCode() ?: 0)
+        result = 31 * result + isValid.hashCode()
+        return result
+    }
+
+    override fun toString(): String {
+        return "StringInputField(value='$value', error=$error, isValid=$isValid)"
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/AddServerCertificateException.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/AddServerCertificateException.kt
new file mode 100644
index 0000000000000000000000000000000000000000..a1cfb8cf2902c94fb34acec0d0c76ed7b9fd214e
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/AddServerCertificateException.kt
@@ -0,0 +1,19 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.feature.account.setup.domain.DomainContract
+import com.fsck.k9.mail.ssl.LocalKeyStore
+import java.security.cert.X509Certificate
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+internal class AddServerCertificateException(
+    private val localKeyStore: LocalKeyStore,
+    private val coroutineDispatcher: CoroutineDispatcher = Dispatchers.IO,
+) : DomainContract.UseCase.AddServerCertificateException {
+    override suspend fun addCertificate(hostname: String, port: Int, certificate: X509Certificate?) {
+        withContext(coroutineDispatcher) {
+            localKeyStore.addCertificate(hostname, port, certificate)
+        }
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/CreateAccount.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/CreateAccount.kt
new file mode 100644
index 0000000000000000000000000000000000000000..bbcc1975a67c0e303b747ef3de1ed8270e54f430
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/CreateAccount.kt
@@ -0,0 +1,33 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.feature.account.setup.AccountSetupExternalContract.AccountCreator
+import app.k9mail.feature.account.setup.AccountSetupExternalContract.AccountCreator.AccountCreatorResult
+import app.k9mail.feature.account.setup.domain.DomainContract.UseCase
+import app.k9mail.feature.account.setup.domain.entity.Account
+import app.k9mail.feature.account.setup.domain.entity.AccountOptions
+import com.fsck.k9.mail.ServerSettings
+
+class CreateAccount(
+    private val accountCreator: AccountCreator,
+) : UseCase.CreateAccount {
+    override suspend fun execute(
+        emailAddress: String,
+        incomingServerSettings: ServerSettings,
+        outgoingServerSettings: ServerSettings,
+        authorizationState: String?,
+        options: AccountOptions,
+    ): String {
+        val account = Account(
+            emailAddress = emailAddress,
+            incomingServerSettings = incomingServerSettings,
+            outgoingServerSettings = outgoingServerSettings,
+            authorizationState = authorizationState,
+            options = options,
+        )
+
+        return when (val result = accountCreator.createAccount(account)) {
+            is AccountCreatorResult.Success -> result.accountUuid
+            is AccountCreatorResult.Error -> "" // TODO change to meaningful error
+        }
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/GetAutoDiscovery.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/GetAutoDiscovery.kt
new file mode 100644
index 0000000000000000000000000000000000000000..9ede91fab5847556de8c4d911a09962dc32590a7
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/GetAutoDiscovery.kt
@@ -0,0 +1,74 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.autodiscovery.api.AuthenticationType
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.autodiscovery.api.AutoDiscoveryService
+import app.k9mail.autodiscovery.api.ImapServerSettings
+import app.k9mail.autodiscovery.api.SmtpServerSettings
+import app.k9mail.core.common.mail.toUserEmailAddress
+import app.k9mail.core.common.oauth.OAuthConfigurationProvider
+import app.k9mail.feature.account.setup.domain.DomainContract
+
+internal class GetAutoDiscovery(
+    private val service: AutoDiscoveryService,
+    private val oauthProvider: OAuthConfigurationProvider,
+) : DomainContract.UseCase.GetAutoDiscovery {
+    override suspend fun execute(emailAddress: String): AutoDiscoveryResult {
+        val email = emailAddress.toUserEmailAddress()
+
+        val result = service.discover(email)
+
+        return if (result is AutoDiscoveryResult.Settings) {
+            validateOAuthSupport(result)
+        } else {
+            result
+        }
+    }
+
+    private fun validateOAuthSupport(settings: AutoDiscoveryResult.Settings): AutoDiscoveryResult {
+        if (settings.incomingServerSettings !is ImapServerSettings) {
+            return AutoDiscoveryResult.NoUsableSettingsFound
+        }
+
+        val incomingServerSettings = settings.incomingServerSettings as ImapServerSettings
+        val outgoingServerSettings = settings.outgoingServerSettings as SmtpServerSettings
+
+        val incomingAuthenticationTypes = cleanAuthenticationTypes(
+            authenticationTypes = incomingServerSettings.authenticationTypes,
+            hostname = incomingServerSettings.hostname.value,
+        )
+        val outgoingAuthenticationTypes = cleanAuthenticationTypes(
+            authenticationTypes = outgoingServerSettings.authenticationTypes,
+            hostname = outgoingServerSettings.hostname.value,
+        )
+
+        return if (incomingAuthenticationTypes.isNotEmpty() && outgoingAuthenticationTypes.isNotEmpty()) {
+            settings.copy(
+                incomingServerSettings = incomingServerSettings.copy(
+                    authenticationTypes = incomingAuthenticationTypes,
+                ),
+                outgoingServerSettings = outgoingServerSettings.copy(
+                    authenticationTypes = outgoingAuthenticationTypes,
+                ),
+            )
+        } else {
+            AutoDiscoveryResult.NoUsableSettingsFound
+        }
+    }
+
+    private fun cleanAuthenticationTypes(
+        authenticationTypes: List<AuthenticationType>,
+        hostname: String,
+    ): List<AuthenticationType> {
+        return if (AuthenticationType.OAuth2 in authenticationTypes && !isOAuthSupportedFor(hostname)) {
+            // OAuth2 is not supported for this hostname; remove it from the list of supported authentication types
+            authenticationTypes.filter { it != AuthenticationType.OAuth2 }
+        } else {
+            authenticationTypes
+        }
+    }
+
+    private fun isOAuthSupportedFor(hostname: String): Boolean {
+        return oauthProvider.getConfiguration(hostname) != null
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateAccountName.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateAccountName.kt
new file mode 100644
index 0000000000000000000000000000000000000000..9366b5aadd62f9a5dbba9ac98c3b592cab2fb6c0
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateAccountName.kt
@@ -0,0 +1,19 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.DomainContract
+
+internal class ValidateAccountName : DomainContract.UseCase.ValidateAccountName {
+    override fun execute(accountName: String): ValidationResult {
+        return when {
+            accountName.isEmpty() -> ValidationResult.Success
+            accountName.isBlank() -> ValidationResult.Failure(ValidateAccountNameError.BlankAccountName)
+            else -> ValidationResult.Success
+        }
+    }
+
+    sealed interface ValidateAccountNameError : ValidationError {
+        object BlankAccountName : ValidateAccountNameError
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateConfigurationApproval.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateConfigurationApproval.kt
new file mode 100644
index 0000000000000000000000000000000000000000..3184af8abaacaf3052c548c730b2e7a7c0058649
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateConfigurationApproval.kt
@@ -0,0 +1,23 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.DomainContract.UseCase
+
+class ValidateConfigurationApproval : UseCase.ValidateConfigurationApproval {
+    override fun execute(isApproved: Boolean?, isAutoDiscoveryTrusted: Boolean?): ValidationResult {
+        return if (isApproved == null && isAutoDiscoveryTrusted == null) {
+            ValidationResult.Success
+        } else if (isAutoDiscoveryTrusted == true) {
+            ValidationResult.Success
+        } else if (isApproved == true) {
+            ValidationResult.Success
+        } else {
+            ValidationResult.Failure(ValidateConfigurationApprovalError.ApprovalRequired)
+        }
+    }
+
+    sealed interface ValidateConfigurationApprovalError : ValidationError {
+        object ApprovalRequired : ValidateConfigurationApprovalError
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateDisplayName.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateDisplayName.kt
new file mode 100644
index 0000000000000000000000000000000000000000..dd57455253ce6a7f431c33b850e4a1863150d33a
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateDisplayName.kt
@@ -0,0 +1,19 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.DomainContract
+
+internal class ValidateDisplayName : DomainContract.UseCase.ValidateDisplayName {
+
+    override fun execute(displayName: String): ValidationResult {
+        return when {
+            displayName.isBlank() -> ValidationResult.Failure(ValidateDisplayNameError.EmptyDisplayName)
+            else -> ValidationResult.Success
+        }
+    }
+
+    sealed interface ValidateDisplayNameError : ValidationError {
+        object EmptyDisplayName : ValidateDisplayNameError
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateEmailAddress.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateEmailAddress.kt
new file mode 100644
index 0000000000000000000000000000000000000000..b53451a62126892f1f698c976273b5f439e631d6
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateEmailAddress.kt
@@ -0,0 +1,31 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.DomainContract
+
+internal class ValidateEmailAddress : DomainContract.UseCase.ValidateEmailAddress {
+
+    // TODO replace by new email validation
+    override fun execute(emailAddress: String): ValidationResult {
+        return when {
+            emailAddress.isBlank() -> ValidationResult.Failure(ValidateEmailAddressError.EmptyEmailAddress)
+
+            !EMAIL_ADDRESS.matches(emailAddress) -> ValidationResult.Failure(
+                ValidateEmailAddressError.InvalidEmailAddress,
+            )
+
+            else -> ValidationResult.Success
+        }
+    }
+
+    sealed interface ValidateEmailAddressError : ValidationError {
+        object EmptyEmailAddress : ValidateEmailAddressError
+        object InvalidEmailAddress : ValidateEmailAddressError
+    }
+
+    private companion object {
+        val EMAIL_ADDRESS =
+            "[a-zA-Z0-9+._%\\-]{1,256}@[a-zA-Z0-9][a-zA-Z0-9\\-]{0,64}(\\.[a-zA-Z0-9][a-zA-Z0-9\\-]{0,25})+".toRegex()
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateEmailSignature.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateEmailSignature.kt
new file mode 100644
index 0000000000000000000000000000000000000000..fd52d8c54ce45d56f39849955531f5708b78b68d
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateEmailSignature.kt
@@ -0,0 +1,22 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.DomainContract
+import app.k9mail.feature.account.setup.domain.usecase.ValidateEmailSignature.ValidateEmailSignatureError.BlankEmailSignature
+
+// TODO check signature for input validity
+internal class ValidateEmailSignature : DomainContract.UseCase.ValidateEmailSignature {
+
+    override fun execute(emailSignature: String): ValidationResult {
+        return when {
+            emailSignature.isEmpty() -> ValidationResult.Success
+            emailSignature.isBlank() -> ValidationResult.Failure(error = BlankEmailSignature)
+            else -> ValidationResult.Success
+        }
+    }
+
+    sealed interface ValidateEmailSignatureError : ValidationError {
+        object BlankEmailSignature : ValidateEmailSignatureError
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateImapPrefix.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateImapPrefix.kt
new file mode 100644
index 0000000000000000000000000000000000000000..486d0725833dced58b35b7fd13e610fa358c8c87
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateImapPrefix.kt
@@ -0,0 +1,21 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.DomainContract
+
+internal class ValidateImapPrefix : DomainContract.UseCase.ValidateImapPrefix {
+
+    override fun execute(imapPrefix: String): ValidationResult {
+        return when {
+            imapPrefix.isEmpty() -> ValidationResult.Success
+            imapPrefix.isBlank() -> ValidationResult.Failure(ValidateImapPrefixError.BlankImapPrefix)
+
+            else -> ValidationResult.Success
+        }
+    }
+
+    sealed interface ValidateImapPrefixError : ValidationError {
+        object BlankImapPrefix : ValidateImapPrefixError
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidatePassword.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidatePassword.kt
new file mode 100644
index 0000000000000000000000000000000000000000..f7c25483226e98ce55c7c0c164960a63187a0d46
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidatePassword.kt
@@ -0,0 +1,21 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.DomainContract
+
+internal class ValidatePassword : DomainContract.UseCase.ValidatePassword {
+
+    // TODO change behavior to allow empty password when no password is required based on auth type
+    override fun execute(password: String): ValidationResult {
+        return when {
+            password.isBlank() -> ValidationResult.Failure(ValidatePasswordError.EmptyPassword)
+
+            else -> ValidationResult.Success
+        }
+    }
+
+    sealed interface ValidatePasswordError : ValidationError {
+        object EmptyPassword : ValidatePasswordError
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidatePort.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidatePort.kt
new file mode 100644
index 0000000000000000000000000000000000000000..f0e31b67b8b5ac070ad4b2b4a8e1e4709bc83b36
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidatePort.kt
@@ -0,0 +1,26 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.DomainContract
+
+internal class ValidatePort : DomainContract.UseCase.ValidatePort {
+
+    override fun execute(port: Long?): ValidationResult {
+        return when (port) {
+            null -> ValidationResult.Failure(ValidatePortError.EmptyPort)
+            in MIN_PORT_NUMBER..MAX_PORT_NUMBER -> ValidationResult.Success
+            else -> ValidationResult.Failure(ValidatePortError.InvalidPort)
+        }
+    }
+
+    sealed interface ValidatePortError : ValidationError {
+        object EmptyPort : ValidatePortError
+        object InvalidPort : ValidatePortError
+    }
+
+    companion object {
+        const val MAX_PORT_NUMBER = 65535
+        const val MIN_PORT_NUMBER = 1
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateServer.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateServer.kt
new file mode 100644
index 0000000000000000000000000000000000000000..31fcfb63df72a1faa0c100e59d4455ad1cce0f49
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateServer.kt
@@ -0,0 +1,20 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.DomainContract
+
+internal class ValidateServer : DomainContract.UseCase.ValidateServer {
+
+    // TODO validate domain, ip4 or ip6
+    override fun execute(server: String): ValidationResult {
+        return when {
+            server.isBlank() -> ValidationResult.Failure(ValidateServerError.EmptyServer)
+            else -> ValidationResult.Success
+        }
+    }
+
+    sealed interface ValidateServerError : ValidationError {
+        object EmptyServer : ValidateServerError
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateServerSettings.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateServerSettings.kt
new file mode 100644
index 0000000000000000000000000000000000000000..0d5a8f4ccd14be8058555fbc3b58a6faa33d89ee
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateServerSettings.kt
@@ -0,0 +1,31 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.feature.account.setup.domain.DomainContract.UseCase
+import com.fsck.k9.mail.ServerSettings
+import com.fsck.k9.mail.oauth.AuthStateStorage
+import com.fsck.k9.mail.server.ServerSettingsValidationResult
+import com.fsck.k9.mail.server.ServerSettingsValidator
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+internal class ValidateServerSettings(
+    private val authStateStorage: AuthStateStorage,
+    private val imapValidator: ServerSettingsValidator,
+    private val pop3Validator: ServerSettingsValidator,
+    private val smtpValidator: ServerSettingsValidator,
+    private val coroutineDispatcher: CoroutineDispatcher = Dispatchers.IO,
+) : UseCase.ValidateServerSettings {
+    override suspend fun execute(settings: ServerSettings): ServerSettingsValidationResult {
+        return withContext(coroutineDispatcher) {
+            when (settings.type) {
+                "imap" -> imapValidator.checkServerSettings(settings, authStateStorage)
+                "pop3" -> pop3Validator.checkServerSettings(settings, authStateStorage)
+                "smtp" -> smtpValidator.checkServerSettings(settings, authStateStorage)
+                else -> {
+                    throw IllegalArgumentException("Unsupported server type: ${settings.type}")
+                }
+            }
+        }
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateUsername.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateUsername.kt
new file mode 100644
index 0000000000000000000000000000000000000000..7399330bb76613eec4a06a38a676f91e0c686afd
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateUsername.kt
@@ -0,0 +1,20 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.DomainContract
+
+internal class ValidateUsername : DomainContract.UseCase.ValidateUsername {
+
+    override fun execute(username: String): ValidationResult {
+        return when {
+            username.isBlank() -> ValidationResult.Failure(ValidateUsernameError.EmptyUsername)
+
+            else -> ValidationResult.Success
+        }
+    }
+
+    sealed interface ValidateUsernameError : ValidationError {
+        object EmptyUsername : ValidateUsernameError
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/navigation/AccountSetupNavigation.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/navigation/AccountSetupNavigation.kt
index 2a9ddfafb9f544077e465ec6ee0b754d8f9ad0fb..a4e95c1fdf81ca9d747b27e6c04177770e77a88d 100644
--- a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/navigation/AccountSetupNavigation.kt
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/navigation/AccountSetupNavigation.kt
@@ -12,14 +12,14 @@ fun NavController.navigateToAccountSetup(navOptions: NavOptions? = null) {
     navigate(NAVIGATION_ROUTE_ACCOUNT_SETUP, navOptions)
 }
 
-fun NavGraphBuilder.accountSetupScreen(
-    onBackClick: () -> Unit,
-    onFinishClick: () -> Unit,
+fun NavGraphBuilder.accountSetupRoute(
+    onBack: () -> Unit,
+    onFinish: (String) -> Unit,
 ) {
     composable(route = NAVIGATION_ROUTE_ACCOUNT_SETUP) {
         AccountSetupScreen(
-            onBackClick = onBackClick,
-            onFinishClick = onFinishClick,
+            onBack = onBack,
+            onFinish = onFinish,
         )
     }
 }
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupContract.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupContract.kt
new file mode 100644
index 0000000000000000000000000000000000000000..8d8651de75fd2cb50386c77195bfe77d98dee300
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupContract.kt
@@ -0,0 +1,41 @@
+package app.k9mail.feature.account.setup.ui
+
+import app.k9mail.core.ui.compose.common.mvi.UnidirectionalViewModel
+
+interface AccountSetupContract {
+
+    enum class SetupStep {
+        AUTO_CONFIG,
+        INCOMING_CONFIG,
+        INCOMING_VALIDATION,
+        OUTGOING_CONFIG,
+        OUTGOING_VALIDATION,
+        OPTIONS,
+    }
+
+    interface ViewModel : UnidirectionalViewModel<State, Event, Effect>
+
+    data class State(
+        val setupStep: SetupStep = SetupStep.AUTO_CONFIG,
+        val isAutomaticConfig: Boolean = false,
+    )
+
+    sealed interface Event {
+        object OnNext : Event
+
+        data class OnAutoDiscoveryFinished(
+            val isAutomaticConfig: Boolean,
+        ) : Event
+
+        object OnBack : Event
+    }
+
+    sealed interface Effect {
+
+        data class NavigateNext(
+            val accountUuid: String,
+        ) : Effect
+
+        object NavigateBack : Effect
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupScreen.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupScreen.kt
index 3dcd99b09ff4d041cc5a8b457a479ddfc2090dfa..91eb2b013c22ab639d4f4900b16dd1f96824ffe2 100644
--- a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupScreen.kt
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupScreen.kt
@@ -1,65 +1,118 @@
 package app.k9mail.feature.account.setup.ui
 
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
 import androidx.compose.ui.tooling.preview.Preview
-import app.k9mail.feature.account.setup.ui.autoconfig.AccountAutoConfigScreen
-import app.k9mail.feature.account.setup.ui.manualconfig.AccountManualConfigScreen
+import app.k9mail.core.ui.compose.common.mvi.observe
+import app.k9mail.feature.account.setup.NAME_INCOMING_VALIDATION
+import app.k9mail.feature.account.setup.NAME_OUTGOING_VALIDATION
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.Effect
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.Event
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.SetupStep
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.ViewModel
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryScreen
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryViewModel
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigScreen
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigViewModel
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract
 import app.k9mail.feature.account.setup.ui.options.AccountOptionsScreen
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsViewModel
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigScreen
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigViewModel
+import app.k9mail.feature.account.setup.ui.validation.AccountValidationContract
+import app.k9mail.feature.account.setup.ui.validation.AccountValidationScreen
+import app.k9mail.feature.account.setup.ui.validation.AccountValidationViewModel
+import org.koin.androidx.compose.koinViewModel
+import org.koin.core.qualifier.named
 
+@Suppress("LongMethod")
 @Composable
 fun AccountSetupScreen(
-    onFinishClick: () -> Unit,
-    onBackClick: () -> Unit,
+    onFinish: (String) -> Unit,
+    onBack: () -> Unit,
+    viewModel: ViewModel = koinViewModel<AccountSetupViewModel>(),
+    autoDiscoveryViewModel: AccountAutoDiscoveryContract.ViewModel = koinViewModel<AccountAutoDiscoveryViewModel>(),
+    incomingViewModel: AccountIncomingConfigContract.ViewModel = koinViewModel<AccountIncomingConfigViewModel>(),
+    incomingValidationViewModel: AccountValidationContract.ViewModel = koinViewModel<AccountValidationViewModel>(
+        named(NAME_INCOMING_VALIDATION),
+    ),
+    outgoingViewModel: AccountOutgoingConfigContract.ViewModel = koinViewModel<AccountOutgoingConfigViewModel>(),
+    outgoingValidationViewModel: AccountValidationContract.ViewModel = koinViewModel<AccountValidationViewModel>(
+        named(NAME_OUTGOING_VALIDATION),
+    ),
+    optionsViewModel: AccountOptionsContract.ViewModel = koinViewModel<AccountOptionsViewModel>(),
 ) {
-    val accountSetupSteps = remember { mutableStateOf(AccountSetupSteps.AUTO_CONFIG) }
+    val (state, dispatch) = viewModel.observe { effect ->
+        when (effect) {
+            is Effect.NavigateNext -> onFinish(effect.accountUuid)
+            Effect.NavigateBack -> onBack()
+        }
+    }
 
-    when (accountSetupSteps.value) {
-        AccountSetupSteps.AUTO_CONFIG -> {
-            AccountAutoConfigScreen(
-                onNextClick = {
-                    // TODO validate config
-                    accountSetupSteps.value = AccountSetupSteps.MANUAL_CONFIG
+    when (state.value.setupStep) {
+        SetupStep.AUTO_CONFIG -> {
+            AccountAutoDiscoveryScreen(
+                onNext = { isAutomaticConfig ->
+                    dispatch(
+                        Event.OnAutoDiscoveryFinished(
+                            isAutomaticConfig,
+                        ),
+                    )
                 },
-                onBackClick = onBackClick,
+                onBack = { dispatch(Event.OnBack) },
+                viewModel = autoDiscoveryViewModel,
             )
         }
 
-        AccountSetupSteps.MANUAL_CONFIG -> {
-            AccountManualConfigScreen(
-                onNextClick = {
-                    accountSetupSteps.value = AccountSetupSteps.OPTIONS
-                },
-                onBackClick = {
-                    accountSetupSteps.value = AccountSetupSteps.AUTO_CONFIG
-                },
+        SetupStep.INCOMING_CONFIG -> {
+            AccountIncomingConfigScreen(
+                onNext = { dispatch(Event.OnNext) },
+                onBack = { dispatch(Event.OnBack) },
+                viewModel = incomingViewModel,
+            )
+        }
+
+        SetupStep.INCOMING_VALIDATION -> {
+            AccountValidationScreen(
+                onNext = { dispatch(Event.OnNext) },
+                onBack = { dispatch(Event.OnBack) },
+                viewModel = incomingValidationViewModel,
+            )
+        }
+
+        SetupStep.OUTGOING_CONFIG -> {
+            AccountOutgoingConfigScreen(
+                onNext = { dispatch(Event.OnNext) },
+                onBack = { dispatch(Event.OnBack) },
+                viewModel = outgoingViewModel,
+            )
+        }
+
+        SetupStep.OUTGOING_VALIDATION -> {
+            AccountValidationScreen(
+                onNext = { dispatch(Event.OnNext) },
+                onBack = { dispatch(Event.OnBack) },
+                viewModel = outgoingValidationViewModel,
             )
         }
 
-        AccountSetupSteps.OPTIONS -> {
+        SetupStep.OPTIONS -> {
             AccountOptionsScreen(
-                // validate account
-                onFinishClick = onFinishClick,
-                onBackClick = {
-                    accountSetupSteps.value = AccountSetupSteps.MANUAL_CONFIG
-                },
+                onNext = { dispatch(Event.OnNext) },
+                onBack = { dispatch(Event.OnBack) },
+                viewModel = optionsViewModel,
             )
         }
     }
 }
 
-enum class AccountSetupSteps {
-    AUTO_CONFIG,
-    MANUAL_CONFIG,
-    OPTIONS,
-}
-
 @Preview(showBackground = true)
 @Composable
 internal fun AccountSetupScreenPreview() {
     AccountSetupScreen(
-        onFinishClick = {},
-        onBackClick = {},
+        onFinish = {},
+        onBack = {},
     )
 }
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupViewModel.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupViewModel.kt
index 26cf5cd18b1fd245fcc0b07a56f95bbb8f8b2f89..8e3d36466b48143e4118e3131cfe43ce36e69f23 100644
--- a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupViewModel.kt
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupViewModel.kt
@@ -1,5 +1,136 @@
 package app.k9mail.feature.account.setup.ui
 
-import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import app.k9mail.core.ui.compose.common.mvi.BaseViewModel
+import app.k9mail.feature.account.oauth.domain.entity.AuthorizationState
+import app.k9mail.feature.account.setup.domain.DomainContract
+import app.k9mail.feature.account.setup.domain.DomainContract.UseCase
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.Effect
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.Event
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.SetupStep
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.State
+import kotlinx.coroutines.launch
 
-class AccountSetupViewModel : ViewModel()
+@Suppress("LongParameterList")
+class AccountSetupViewModel(
+    private val createAccount: UseCase.CreateAccount,
+    private val accountSetupStateRepository: DomainContract.AccountSetupStateRepository,
+    initialState: State = State(),
+) : BaseViewModel<State, Event, Effect>(initialState), AccountSetupContract.ViewModel {
+
+    override fun event(event: Event) {
+        when (event) {
+            is Event.OnAutoDiscoveryFinished -> onAutoDiscoveryFinished(event.isAutomaticConfig)
+
+            Event.OnBack -> onBack()
+            Event.OnNext -> onNext()
+        }
+    }
+
+    private fun onAutoDiscoveryFinished(
+        isAutomaticConfig: Boolean,
+    ) {
+        updateState {
+            it.copy(
+                isAutomaticConfig = isAutomaticConfig,
+            )
+        }
+
+        onNext()
+    }
+
+    private fun onNext() {
+        when (state.value.setupStep) {
+            SetupStep.AUTO_CONFIG -> {
+                if (state.value.isAutomaticConfig) {
+                    changeToSetupStep(SetupStep.INCOMING_VALIDATION)
+                } else {
+                    changeToSetupStep(SetupStep.INCOMING_CONFIG)
+                }
+            }
+
+            SetupStep.INCOMING_CONFIG -> {
+                changeToSetupStep(SetupStep.INCOMING_VALIDATION)
+            }
+
+            SetupStep.INCOMING_VALIDATION -> {
+                if (state.value.isAutomaticConfig) {
+                    changeToSetupStep(SetupStep.OUTGOING_VALIDATION)
+                } else {
+                    changeToSetupStep(SetupStep.OUTGOING_CONFIG)
+                }
+            }
+
+            SetupStep.OUTGOING_CONFIG -> {
+                changeToSetupStep(SetupStep.OUTGOING_VALIDATION)
+            }
+
+            SetupStep.OUTGOING_VALIDATION -> {
+                changeToSetupStep(SetupStep.OPTIONS)
+            }
+
+            SetupStep.OPTIONS -> onFinish()
+        }
+    }
+
+    private fun onBack() {
+        when (state.value.setupStep) {
+            SetupStep.AUTO_CONFIG -> navigateBack()
+            SetupStep.INCOMING_CONFIG -> changeToSetupStep(SetupStep.AUTO_CONFIG)
+            SetupStep.INCOMING_VALIDATION -> {
+                if (state.value.isAutomaticConfig) {
+                    changeToSetupStep(SetupStep.AUTO_CONFIG)
+                } else {
+                    changeToSetupStep(SetupStep.INCOMING_CONFIG)
+                }
+            }
+
+            SetupStep.OUTGOING_CONFIG -> changeToSetupStep(SetupStep.INCOMING_CONFIG)
+            SetupStep.OUTGOING_VALIDATION -> {
+                if (state.value.isAutomaticConfig) {
+                    changeToSetupStep(SetupStep.AUTO_CONFIG)
+                } else {
+                    changeToSetupStep(SetupStep.OUTGOING_CONFIG)
+                }
+            }
+
+            SetupStep.OPTIONS -> if (state.value.isAutomaticConfig) {
+                changeToSetupStep(SetupStep.AUTO_CONFIG)
+            } else {
+                changeToSetupStep(SetupStep.OUTGOING_CONFIG)
+            }
+        }
+    }
+
+    private fun changeToSetupStep(setupStep: SetupStep) {
+        if (setupStep == SetupStep.AUTO_CONFIG) {
+            accountSetupStateRepository.saveAuthorizationState(AuthorizationState(null))
+        }
+
+        updateState {
+            it.copy(
+                setupStep = setupStep,
+            )
+        }
+    }
+
+    private fun onFinish() {
+        val accountSetupState = accountSetupStateRepository.getState()
+
+        viewModelScope.launch {
+            val result = createAccount.execute(
+                emailAddress = accountSetupState.emailAddress ?: "",
+                incomingServerSettings = accountSetupState.incomingServerSettings!!,
+                outgoingServerSettings = accountSetupState.outgoingServerSettings!!,
+                authorizationState = accountSetupState.authorizationState?.state,
+                options = accountSetupState.options!!,
+            )
+
+            navigateNext(result)
+        }
+    }
+
+    private fun navigateNext(accountUuid: String) = emitEffect(Effect.NavigateNext(accountUuid))
+
+    private fun navigateBack() = emitEffect(Effect.NavigateBack)
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autoconfig/AccountAutoConfigContent.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autoconfig/AccountAutoConfigContent.kt
deleted file mode 100644
index 69c60bfc826e910a773760ebbf02fb343caa4877..0000000000000000000000000000000000000000
--- a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autoconfig/AccountAutoConfigContent.kt
+++ /dev/null
@@ -1,141 +0,0 @@
-package app.k9mail.feature.account.setup.ui.autoconfig
-
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.requiredHeight
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.res.stringResource
-import app.k9mail.core.ui.compose.common.DevicePreviews
-import app.k9mail.core.ui.compose.designsystem.atom.button.Button
-import app.k9mail.core.ui.compose.designsystem.atom.button.ButtonOutlined
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline2
-import app.k9mail.core.ui.compose.designsystem.atom.textfield.TextFieldOutlined
-import app.k9mail.core.ui.compose.designsystem.template.LazyColumnWithHeaderFooter
-import app.k9mail.core.ui.compose.designsystem.template.ResponsiveContentWithBackground
-import app.k9mail.core.ui.compose.theme.K9Theme
-import app.k9mail.core.ui.compose.theme.MainTheme
-import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
-import app.k9mail.feature.account.setup.R
-
-@Composable
-internal fun AccountAutoConfigContent(
-    onNextClick: () -> Unit,
-    onBackClick: () -> Unit,
-    modifier: Modifier = Modifier,
-) {
-    ResponsiveContentWithBackground(
-        modifier = modifier,
-    ) {
-        LazyColumnWithHeaderFooter(
-            modifier = Modifier.fillMaxSize(),
-            header = {
-                AccountSetupHeader()
-            },
-            footer = {
-                AccountSetupFooter(
-                    onNextClick = onNextClick,
-                    onBackClick = onBackClick,
-                )
-            },
-            verticalArrangement = Arrangement.spacedBy(MainTheme.spacings.double, Alignment.CenterVertically),
-        ) {
-            item { Spacer(modifier = Modifier.height(MainTheme.sizes.larger)) }
-            item {
-                AccountSetupEmailForm(
-                    modifier = Modifier.fillMaxWidth(),
-                )
-            }
-            item { Spacer(modifier = Modifier.height(MainTheme.sizes.larger)) }
-        }
-    }
-}
-
-@Composable
-private fun AccountSetupHeader(
-    modifier: Modifier = Modifier,
-) {
-    Column(
-        modifier = Modifier
-            .fillMaxWidth()
-            .padding(
-                start = MainTheme.spacings.double,
-                end = MainTheme.spacings.double,
-                bottom = MainTheme.spacings.triple,
-            )
-            .requiredHeight(MainTheme.sizes.larger)
-            .then(modifier),
-        horizontalAlignment = Alignment.CenterHorizontally,
-        verticalArrangement = Arrangement.Bottom,
-    ) {
-        TextHeadline2(text = stringResource(id = R.string.account_setup_title))
-    }
-}
-
-@Composable
-private fun AccountSetupEmailForm(
-    modifier: Modifier = Modifier,
-) {
-    Column(
-        modifier = modifier,
-        horizontalAlignment = Alignment.CenterHorizontally,
-    ) {
-        TextFieldOutlined(
-            value = "",
-            onValueChange = { /*TODO*/ },
-            label = "Email address",
-        )
-    }
-}
-
-@Composable
-private fun AccountSetupFooter(
-    onNextClick: () -> Unit,
-    onBackClick: () -> Unit,
-    modifier: Modifier = Modifier,
-) {
-    Row(
-        modifier = Modifier
-            .fillMaxWidth()
-            .padding(
-                start = MainTheme.spacings.quadruple,
-                top = MainTheme.spacings.triple,
-                end = MainTheme.spacings.quadruple,
-                bottom = MainTheme.spacings.double,
-            )
-            .then(modifier),
-        horizontalArrangement = Arrangement.SpaceBetween,
-    ) {
-        ButtonOutlined(
-            text = stringResource(id = R.string.account_setup_button_back),
-            onClick = onBackClick,
-        )
-        Button(
-            text = stringResource(id = R.string.account_setup_button_next),
-            onClick = onNextClick,
-        )
-    }
-}
-
-@Composable
-@DevicePreviews
-internal fun AccountAutoConfigContentK9Preview() {
-    K9Theme {
-        AccountAutoConfigContent({}, {})
-    }
-}
-
-@Composable
-@DevicePreviews
-internal fun AccountAutoConfigContentThunderbirdPreview() {
-    ThunderbirdTheme {
-        AccountAutoConfigContent({}, {})
-    }
-}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autoconfig/AccountAutoConfigScreen.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autoconfig/AccountAutoConfigScreen.kt
deleted file mode 100644
index 75b20c9c25371bb413703e83123b1de3940b4dc4..0000000000000000000000000000000000000000
--- a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autoconfig/AccountAutoConfigScreen.kt
+++ /dev/null
@@ -1,14 +0,0 @@
-package app.k9mail.feature.account.setup.ui.autoconfig
-
-import androidx.compose.runtime.Composable
-
-@Composable
-fun AccountAutoConfigScreen(
-    onNextClick: () -> Unit,
-    onBackClick: () -> Unit,
-) {
-    AccountAutoConfigContent(
-        onNextClick = onNextClick,
-        onBackClick = onBackClick,
-    )
-}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryContent.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryContent.kt
new file mode 100644
index 0000000000000000000000000000000000000000..a0dd9b217ed8197a35b81b626a5d6141c68cbf2c
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryContent.kt
@@ -0,0 +1,102 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.imePadding
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.stringResource
+import app.k9mail.core.ui.compose.common.DevicePreviews
+import app.k9mail.core.ui.compose.designsystem.template.ResponsiveWidthContainer
+import app.k9mail.core.ui.compose.theme.K9Theme
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
+import app.k9mail.feature.account.common.ui.item.ErrorItem
+import app.k9mail.feature.account.common.ui.item.LoadingItem
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract
+import app.k9mail.feature.account.oauth.ui.preview.PreviewAccountOAuthViewModel
+import app.k9mail.feature.account.setup.R
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.Event
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.State
+import app.k9mail.feature.account.setup.ui.autodiscovery.item.contentItems
+
+@Composable
+internal fun AccountAutoDiscoveryContent(
+    state: State,
+    onEvent: (Event) -> Unit,
+    oAuthViewModel: AccountOAuthContract.ViewModel,
+    contentPadding: PaddingValues,
+    modifier: Modifier = Modifier,
+) {
+    ResponsiveWidthContainer(
+        modifier = Modifier
+            .testTag("AccountAutoDiscoveryContent")
+            .padding(contentPadding)
+            .fillMaxWidth()
+            .then(modifier),
+    ) {
+        val resources = LocalContext.current.resources
+
+        LazyColumn(
+            modifier = Modifier
+                .fillMaxSize()
+                .imePadding(),
+            verticalArrangement = Arrangement.spacedBy(MainTheme.spacings.double, Alignment.CenterVertically),
+        ) {
+            if (state.isLoading) {
+                item(key = "loading") {
+                    LoadingItem(
+                        message = stringResource(id = R.string.account_setup_auto_config_loading_message),
+                    )
+                }
+            } else if (state.error != null) {
+                item(key = "error") {
+                    ErrorItem(
+                        title = stringResource(id = R.string.account_setup_auto_config_loading_error),
+                        message = state.error.toResourceString(resources),
+                        onRetry = { onEvent(Event.OnRetryClicked) },
+                    )
+                }
+            } else {
+                contentItems(
+                    state = state,
+                    onEvent = onEvent,
+                    oAuthViewModel = oAuthViewModel,
+                )
+            }
+        }
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountAutoDiscoveryContentK9Preview() {
+    K9Theme {
+        AccountAutoDiscoveryContent(
+            state = State(),
+            onEvent = {},
+            contentPadding = PaddingValues(),
+            oAuthViewModel = PreviewAccountOAuthViewModel(),
+        )
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountAutoDiscoveryContentThunderbirdPreview() {
+    ThunderbirdTheme {
+        AccountAutoDiscoveryContent(
+            state = State(),
+            onEvent = {},
+            contentPadding = PaddingValues(),
+            oAuthViewModel = PreviewAccountOAuthViewModel(),
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryContract.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryContract.kt
new file mode 100644
index 0000000000000000000000000000000000000000..346b34d537bd9cbe279186adf7f810480bbb8975
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryContract.kt
@@ -0,0 +1,69 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery
+
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.core.ui.compose.common.mvi.UnidirectionalViewModel
+import app.k9mail.feature.account.oauth.domain.entity.AuthorizationState
+import app.k9mail.feature.account.oauth.domain.entity.OAuthResult
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract
+import app.k9mail.feature.account.setup.domain.input.BooleanInputField
+import app.k9mail.feature.account.setup.domain.input.StringInputField
+
+interface AccountAutoDiscoveryContract {
+
+    enum class ConfigStep {
+        EMAIL_ADDRESS,
+        OAUTH,
+        PASSWORD,
+    }
+
+    interface ViewModel : UnidirectionalViewModel<State, Event, Effect> {
+        val oAuthViewModel: AccountOAuthContract.ViewModel
+
+        fun initState(state: State)
+    }
+
+    data class State(
+        val configStep: ConfigStep = ConfigStep.EMAIL_ADDRESS,
+        val emailAddress: StringInputField = StringInputField(),
+        val password: StringInputField = StringInputField(),
+        val autoDiscoverySettings: AutoDiscoveryResult.Settings? = null,
+        val configurationApproved: BooleanInputField = BooleanInputField(),
+        val authorizationState: AuthorizationState? = null,
+
+        val isSuccess: Boolean = false,
+        val error: Error? = null,
+        val isLoading: Boolean = false,
+
+        val isNextButtonVisible: Boolean = true,
+    )
+
+    sealed interface Event {
+        data class EmailAddressChanged(val emailAddress: String) : Event
+        data class PasswordChanged(val password: String) : Event
+        data class ConfigurationApprovalChanged(val confirmed: Boolean) : Event
+        data class OnOAuthResult(val result: OAuthResult) : Event
+
+        object OnNextClicked : Event
+        object OnBackClicked : Event
+        object OnRetryClicked : Event
+        object OnEditConfigurationClicked : Event
+    }
+
+    sealed class Effect {
+        data class NavigateNext(val isAutomaticConfig: Boolean) : Effect()
+
+        object NavigateBack : Effect()
+    }
+
+    interface Validator {
+        fun validateEmailAddress(emailAddress: String): ValidationResult
+        fun validatePassword(password: String): ValidationResult
+        fun validateConfigurationApproval(isApproved: Boolean?, isAutoDiscoveryTrusted: Boolean?): ValidationResult
+    }
+
+    sealed interface Error {
+        object NetworkError : Error
+        object UnknownError : Error
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryScreen.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryScreen.kt
new file mode 100644
index 0000000000000000000000000000000000000000..b533c38788a073c2501c9a4891bf7792f51a448b
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryScreen.kt
@@ -0,0 +1,99 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery
+
+import androidx.activity.compose.BackHandler
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.core.ui.compose.common.DevicePreviews
+import app.k9mail.core.ui.compose.common.mvi.observe
+import app.k9mail.core.ui.compose.designsystem.template.Scaffold
+import app.k9mail.core.ui.compose.theme.K9Theme
+import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
+import app.k9mail.feature.account.common.ui.AppTitleTopHeader
+import app.k9mail.feature.account.common.ui.WizardNavigationBar
+import app.k9mail.feature.account.common.ui.WizardNavigationBarState
+import app.k9mail.feature.account.oauth.ui.preview.PreviewAccountOAuthViewModel
+import app.k9mail.feature.account.setup.R
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.Effect
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.Event
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.ViewModel
+import app.k9mail.feature.account.setup.ui.preview.PreviewAccountSetupStateRepository
+
+@Composable
+internal fun AccountAutoDiscoveryScreen(
+    onNext: (isAutomaticConfig: Boolean) -> Unit,
+    onBack: () -> Unit,
+    viewModel: ViewModel,
+    modifier: Modifier = Modifier,
+) {
+    val (state, dispatch) = viewModel.observe { effect ->
+        when (effect) {
+            Effect.NavigateBack -> onBack()
+            is Effect.NavigateNext -> onNext(effect.isAutomaticConfig)
+        }
+    }
+
+    BackHandler {
+        dispatch(Event.OnBackClicked)
+    }
+
+    Scaffold(
+        topBar = {
+            AppTitleTopHeader(
+                title = stringResource(id = R.string.account_setup_title),
+            )
+        },
+        bottomBar = {
+            WizardNavigationBar(
+                nextButtonText = stringResource(id = R.string.account_setup_button_next),
+                backButtonText = stringResource(id = R.string.account_setup_button_back),
+                onNextClick = { dispatch(Event.OnNextClicked) },
+                onBackClick = { dispatch(Event.OnBackClicked) },
+                state = WizardNavigationBarState(showNext = state.value.isNextButtonVisible),
+            )
+        },
+        modifier = modifier,
+    ) { innerPadding ->
+        AccountAutoDiscoveryContent(
+            state = state.value,
+            onEvent = { dispatch(it) },
+            oAuthViewModel = viewModel.oAuthViewModel,
+            contentPadding = innerPadding,
+        )
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountAutoDiscoveryScreenK9Preview() {
+    K9Theme {
+        AccountAutoDiscoveryScreen(
+            onNext = {},
+            onBack = {},
+            viewModel = AccountAutoDiscoveryViewModel(
+                validator = AccountAutoDiscoveryValidator(),
+                getAutoDiscovery = { AutoDiscoveryResult.NoUsableSettingsFound },
+                accountSetupStateRepository = PreviewAccountSetupStateRepository(),
+                oAuthViewModel = PreviewAccountOAuthViewModel(),
+            ),
+        )
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountAutoDiscoveryScreenThunderbirdPreview() {
+    ThunderbirdTheme {
+        AccountAutoDiscoveryScreen(
+            onNext = { },
+            onBack = {},
+            viewModel = AccountAutoDiscoveryViewModel(
+                validator = AccountAutoDiscoveryValidator(),
+                getAutoDiscovery = { AutoDiscoveryResult.NoUsableSettingsFound },
+                accountSetupStateRepository = PreviewAccountSetupStateRepository(),
+                oAuthViewModel = PreviewAccountOAuthViewModel(),
+            ),
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryStateMapper.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryStateMapper.kt
new file mode 100644
index 0000000000000000000000000000000000000000..27ad77184e11ddbd3f134e6af30b17d05397bc85
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryStateMapper.kt
@@ -0,0 +1,69 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery
+
+import app.k9mail.autodiscovery.api.ImapServerSettings
+import app.k9mail.autodiscovery.api.SmtpServerSettings
+import app.k9mail.feature.account.setup.domain.entity.AccountSetupState
+import app.k9mail.feature.account.setup.domain.entity.toAuthenticationType
+import app.k9mail.feature.account.setup.domain.entity.toConnectionSecurity
+import app.k9mail.feature.account.setup.domain.entity.toIncomingProtocolType
+import app.k9mail.feature.account.setup.domain.input.NumberInputField
+import app.k9mail.feature.account.setup.domain.input.StringInputField
+import app.k9mail.feature.account.setup.domain.toServerSettings
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract
+
+internal fun AccountAutoDiscoveryContract.State.toAccountSetupState(): AccountSetupState {
+    return AccountSetupState(
+        emailAddress = emailAddress.value,
+        incomingServerSettings = autoDiscoverySettings?.incomingServerSettings?.toServerSettings(password.value),
+        outgoingServerSettings = autoDiscoverySettings?.outgoingServerSettings?.toServerSettings(password.value),
+        authorizationState = authorizationState,
+        options = null,
+    )
+}
+
+internal fun AccountAutoDiscoveryContract.State.toIncomingConfigState(): AccountIncomingConfigContract.State {
+    val incomingSettings = autoDiscoverySettings?.incomingServerSettings as? ImapServerSettings?
+    return if (incomingSettings == null) {
+        AccountIncomingConfigContract.State(
+            username = StringInputField(value = emailAddress.value),
+            password = StringInputField(value = password.value),
+        )
+    } else {
+        AccountIncomingConfigContract.State(
+            protocolType = incomingSettings.toIncomingProtocolType(),
+            server = StringInputField(value = incomingSettings.hostname.value),
+            security = incomingSettings.connectionSecurity.toConnectionSecurity(),
+            port = NumberInputField(value = incomingSettings.port.value.toLong()),
+            authenticationType = incomingSettings.authenticationTypes.first().toAuthenticationType(),
+            username = StringInputField(value = incomingSettings.username),
+            password = StringInputField(value = password.value),
+        )
+    }
+}
+
+internal fun AccountAutoDiscoveryContract.State.toOutgoingConfigState(): AccountOutgoingConfigContract.State {
+    val outgoingSettings = autoDiscoverySettings?.outgoingServerSettings as? SmtpServerSettings?
+    return if (outgoingSettings == null) {
+        AccountOutgoingConfigContract.State(
+            username = StringInputField(value = emailAddress.value),
+            password = StringInputField(value = password.value),
+        )
+    } else {
+        AccountOutgoingConfigContract.State(
+            server = StringInputField(value = outgoingSettings.hostname.value),
+            security = outgoingSettings.connectionSecurity.toConnectionSecurity(),
+            port = NumberInputField(value = outgoingSettings.port.value.toLong()),
+            authenticationType = outgoingSettings.authenticationTypes.first().toAuthenticationType(),
+            username = StringInputField(value = outgoingSettings.username),
+            password = StringInputField(value = password.value),
+        )
+    }
+}
+
+internal fun AccountAutoDiscoveryContract.State.toOptionsState(): AccountOptionsContract.State {
+    return AccountOptionsContract.State(
+        accountName = StringInputField(value = emailAddress.value),
+    )
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryValidator.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryValidator.kt
new file mode 100644
index 0000000000000000000000000000000000000000..2ae80059e509faa8599ce6b8fe667839493ba861
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryValidator.kt
@@ -0,0 +1,29 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.DomainContract.UseCase
+import app.k9mail.feature.account.setup.domain.usecase.ValidateConfigurationApproval
+import app.k9mail.feature.account.setup.domain.usecase.ValidateEmailAddress
+import app.k9mail.feature.account.setup.domain.usecase.ValidatePassword
+
+internal class AccountAutoDiscoveryValidator(
+    private val emailAddressValidator: UseCase.ValidateEmailAddress = ValidateEmailAddress(),
+    private val passwordValidator: UseCase.ValidatePassword = ValidatePassword(),
+    private val configurationApprovalValidator: UseCase.ValidateConfigurationApproval = ValidateConfigurationApproval(),
+) : AccountAutoDiscoveryContract.Validator {
+
+    override fun validateEmailAddress(emailAddress: String): ValidationResult {
+        return emailAddressValidator.execute(emailAddress)
+    }
+
+    override fun validatePassword(password: String): ValidationResult {
+        return passwordValidator.execute(password)
+    }
+
+    override fun validateConfigurationApproval(
+        isApproved: Boolean?,
+        isAutoDiscoveryTrusted: Boolean?,
+    ): ValidationResult {
+        return configurationApprovalValidator.execute(isApproved, isAutoDiscoveryTrusted)
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryViewModel.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryViewModel.kt
new file mode 100644
index 0000000000000000000000000000000000000000..fec25ba15cb302422e7c1c8aa4958c8b8a15d812
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryViewModel.kt
@@ -0,0 +1,257 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery
+
+import androidx.lifecycle.viewModelScope
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.autodiscovery.api.ImapServerSettings
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.core.ui.compose.common.mvi.BaseViewModel
+import app.k9mail.feature.account.oauth.domain.entity.OAuthResult
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract
+import app.k9mail.feature.account.setup.domain.DomainContract
+import app.k9mail.feature.account.setup.domain.DomainContract.UseCase
+import app.k9mail.feature.account.setup.domain.entity.AutoDiscoveryAuthenticationType
+import app.k9mail.feature.account.setup.domain.input.StringInputField
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.ConfigStep
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.Effect
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.Error
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.Event
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.State
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.Validator
+import kotlinx.coroutines.launch
+
+@Suppress("TooManyFunctions")
+internal class AccountAutoDiscoveryViewModel(
+    initialState: State = State(),
+    private val validator: Validator,
+    private val getAutoDiscovery: UseCase.GetAutoDiscovery,
+    private val accountSetupStateRepository: DomainContract.AccountSetupStateRepository,
+    override val oAuthViewModel: AccountOAuthContract.ViewModel,
+) : BaseViewModel<State, Event, Effect>(initialState), AccountAutoDiscoveryContract.ViewModel {
+
+    override fun initState(state: State) {
+        updateState {
+            state.copy()
+        }
+    }
+
+    override fun event(event: Event) {
+        when (event) {
+            is Event.EmailAddressChanged -> changeEmailAddress(event.emailAddress)
+            is Event.PasswordChanged -> changePassword(event.password)
+            is Event.ConfigurationApprovalChanged -> changeConfigurationApproval(event.confirmed)
+            is Event.OnOAuthResult -> onOAuthResult(event.result)
+
+            Event.OnNextClicked -> onNext()
+            Event.OnBackClicked -> onBack()
+            Event.OnRetryClicked -> onRetry()
+            Event.OnEditConfigurationClicked -> {
+                navigateNext(isAutomaticConfig = false)
+            }
+        }
+    }
+
+    private fun changeEmailAddress(emailAddress: String) {
+        accountSetupStateRepository.clear()
+        updateState {
+            State(
+                emailAddress = StringInputField(value = emailAddress),
+                isNextButtonVisible = true,
+            )
+        }
+    }
+
+    private fun changePassword(password: String) {
+        updateState {
+            it.copy(
+                password = it.password.updateValue(password),
+            )
+        }
+    }
+
+    private fun changeConfigurationApproval(approved: Boolean) {
+        updateState {
+            it.copy(
+                configurationApproved = it.configurationApproved.updateValue(approved),
+            )
+        }
+    }
+
+    private fun onNext() {
+        when (state.value.configStep) {
+            ConfigStep.EMAIL_ADDRESS ->
+                if (state.value.error != null) {
+                    updateState {
+                        it.copy(
+                            error = null,
+                            configStep = ConfigStep.PASSWORD,
+                        )
+                    }
+                } else {
+                    submitEmail()
+                }
+
+            ConfigStep.PASSWORD -> submitPassword()
+            ConfigStep.OAUTH -> Unit
+        }
+    }
+
+    private fun onRetry() {
+        updateState {
+            it.copy(error = null)
+        }
+        loadAutoDiscovery()
+    }
+
+    private fun submitEmail() {
+        with(state.value) {
+            val emailValidationResult = validator.validateEmailAddress(emailAddress.value)
+            val hasError = emailValidationResult is ValidationResult.Failure
+
+            updateState {
+                it.copy(
+                    emailAddress = it.emailAddress.updateFromValidationResult(emailValidationResult),
+                )
+            }
+
+            if (!hasError) {
+                loadAutoDiscovery()
+            }
+        }
+    }
+
+    private fun loadAutoDiscovery() {
+        viewModelScope.launch {
+            updateState {
+                it.copy(
+                    isLoading = true,
+                )
+            }
+
+            val result = getAutoDiscovery.execute(state.value.emailAddress.value)
+            when (result) {
+                AutoDiscoveryResult.NoUsableSettingsFound -> updateNoSettingsFound()
+                is AutoDiscoveryResult.Settings -> updateAutoDiscoverySettings(result)
+                is AutoDiscoveryResult.NetworkError -> updateError(Error.NetworkError)
+                is AutoDiscoveryResult.UnexpectedException -> updateError(Error.UnknownError)
+            }
+        }
+    }
+
+    private fun updateNoSettingsFound() {
+        updateState {
+            it.copy(
+                isLoading = false,
+                autoDiscoverySettings = null,
+                configStep = ConfigStep.PASSWORD,
+            )
+        }
+    }
+
+    private fun updateAutoDiscoverySettings(settings: AutoDiscoveryResult.Settings) {
+        val imapServerSettings = settings.incomingServerSettings as ImapServerSettings
+        val isOAuth = imapServerSettings.authenticationTypes.first() == AutoDiscoveryAuthenticationType.OAuth2
+
+        if (isOAuth) {
+            oAuthViewModel.initState(
+                AccountOAuthContract.State(
+                    hostname = imapServerSettings.hostname.value,
+                    emailAddress = state.value.emailAddress.value,
+                ),
+            )
+        }
+
+        updateState {
+            it.copy(
+                isLoading = false,
+                autoDiscoverySettings = settings,
+                configStep = if (isOAuth) ConfigStep.OAUTH else ConfigStep.PASSWORD,
+                isNextButtonVisible = !isOAuth,
+            )
+        }
+    }
+
+    private fun updateError(error: Error) {
+        updateState {
+            it.copy(
+                isLoading = false,
+                error = error,
+            )
+        }
+    }
+
+    private fun submitPassword() {
+        with(state.value) {
+            val emailValidationResult = validator.validateEmailAddress(emailAddress.value)
+            val passwordValidationResult = validator.validatePassword(password.value)
+            val configurationApprovalValidationResult = validator.validateConfigurationApproval(
+                isApproved = configurationApproved.value,
+                isAutoDiscoveryTrusted = autoDiscoverySettings?.isTrusted,
+            )
+            val hasError = listOf(
+                emailValidationResult,
+                passwordValidationResult,
+                configurationApprovalValidationResult,
+            ).any { it is ValidationResult.Failure }
+
+            updateState {
+                it.copy(
+                    emailAddress = it.emailAddress.updateFromValidationResult(emailValidationResult),
+                    password = it.password.updateFromValidationResult(passwordValidationResult),
+                    configurationApproved = it.configurationApproved.updateFromValidationResult(
+                        configurationApprovalValidationResult,
+                    ),
+                )
+            }
+
+            if (!hasError) {
+                navigateNext(state.value.autoDiscoverySettings != null)
+            }
+        }
+    }
+
+    private fun onBack() {
+        when (state.value.configStep) {
+            ConfigStep.EMAIL_ADDRESS -> {
+                if (state.value.error != null) {
+                    updateState {
+                        it.copy(error = null)
+                    }
+                } else {
+                    navigateBack()
+                }
+            }
+
+            ConfigStep.OAUTH,
+            ConfigStep.PASSWORD,
+            -> updateState {
+                it.copy(
+                    configStep = ConfigStep.EMAIL_ADDRESS,
+                    password = StringInputField(),
+                    isNextButtonVisible = true,
+                )
+            }
+        }
+    }
+
+    private fun onOAuthResult(result: OAuthResult) {
+        if (result is OAuthResult.Success) {
+            updateState {
+                it.copy(authorizationState = result.authorizationState)
+            }
+
+            navigateNext(isAutomaticConfig = true)
+        } else {
+            updateState {
+                it.copy(authorizationState = null)
+            }
+        }
+    }
+
+    private fun navigateBack() = emitEffect(Effect.NavigateBack)
+
+    private fun navigateNext(isAutomaticConfig: Boolean) {
+        accountSetupStateRepository.save(state.value.toAccountSetupState())
+
+        emitEffect(Effect.NavigateNext(isAutomaticConfig))
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AutoDiscoveryStringMapper.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AutoDiscoveryStringMapper.kt
new file mode 100644
index 0000000000000000000000000000000000000000..19d8749ce7b9679f79b6631650822dbfbeb49dde
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AutoDiscoveryStringMapper.kt
@@ -0,0 +1,46 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery
+
+import android.content.res.Resources
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.feature.account.setup.R
+import app.k9mail.feature.account.setup.domain.entity.AutoDiscoveryConnectionSecurity
+import app.k9mail.feature.account.setup.domain.usecase.ValidateConfigurationApproval
+
+internal fun AutoDiscoveryConnectionSecurity.toResourceString(resources: Resources): String {
+    return when (this) {
+        AutoDiscoveryConnectionSecurity.StartTLS -> resources.getString(
+            R.string.account_setup_connection_security_start_tls,
+        )
+
+        AutoDiscoveryConnectionSecurity.TLS -> resources.getString(
+            R.string.account_setup_connection_security_ssl,
+        )
+    }
+}
+
+internal fun AccountAutoDiscoveryContract.Error.toResourceString(resources: Resources): String {
+    return when (this) {
+        AccountAutoDiscoveryContract.Error.NetworkError -> resources.getString(R.string.account_setup_error_network)
+        AccountAutoDiscoveryContract.Error.UnknownError -> resources.getString(R.string.account_setup_error_unknown)
+    }
+}
+
+internal fun ValidationError.toResourceString(resources: Resources): String {
+    return when (this) {
+        is ValidateConfigurationApproval.ValidateConfigurationApprovalError -> toConfigurationApprovalErrorString(
+            resources,
+        )
+
+        else -> throw IllegalArgumentException("Unknown error: $this")
+    }
+}
+
+private fun ValidateConfigurationApproval.ValidateConfigurationApprovalError.toConfigurationApprovalErrorString(
+    resources: Resources,
+): String {
+    return when (this) {
+        ValidateConfigurationApproval.ValidateConfigurationApprovalError.ApprovalRequired -> resources.getString(
+            R.string.account_setup_error_configuration_approval_required,
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/item/AutoDiscoveryStatusItem.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/item/AutoDiscoveryStatusItem.kt
new file mode 100644
index 0000000000000000000000000000000000000000..532ac67e93281e50ac9c7d18e28a8a63f7547480
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/item/AutoDiscoveryStatusItem.kt
@@ -0,0 +1,24 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery.item
+
+import androidx.compose.foundation.lazy.LazyItemScope
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.feature.account.common.ui.item.ListItem
+import app.k9mail.feature.account.setup.ui.autodiscovery.view.AutoDiscoveryStatusView
+
+@Composable
+internal fun LazyItemScope.AutoDiscoveryStatusItem(
+    autoDiscoverySettings: AutoDiscoveryResult.Settings?,
+    onEditConfigurationClick: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    ListItem(
+        modifier = modifier,
+    ) {
+        AutoDiscoveryStatusView(
+            settings = autoDiscoverySettings,
+            onEditConfigurationClick = onEditConfigurationClick,
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/item/ConfigurationApprovalItem.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/item/ConfigurationApprovalItem.kt
new file mode 100644
index 0000000000000000000000000000000000000000..dc7bac30968507843fd67dba702551d24a25ad40
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/item/ConfigurationApprovalItem.kt
@@ -0,0 +1,24 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery.item
+
+import androidx.compose.foundation.lazy.LazyItemScope
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import app.k9mail.feature.account.common.ui.item.ListItem
+import app.k9mail.feature.account.setup.domain.input.BooleanInputField
+import app.k9mail.feature.account.setup.ui.autodiscovery.view.ConfigurationApprovalView
+
+@Composable
+internal fun LazyItemScope.ConfigurationApprovalItem(
+    approvalState: BooleanInputField,
+    onConfigurationApprovalChange: (Boolean) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    ListItem(
+        modifier = modifier,
+    ) {
+        ConfigurationApprovalView(
+            approvalState = approvalState,
+            onConfigurationApprovalChange = onConfigurationApprovalChange,
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/item/ContentItems.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/item/ContentItems.kt
new file mode 100644
index 0000000000000000000000000000000000000000..331a153a2ca8ab15cecdbfbd528903c1f4bad88b
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/item/ContentItems.kt
@@ -0,0 +1,59 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery.item
+
+import androidx.compose.foundation.lazy.LazyListScope
+import app.k9mail.feature.account.common.ui.item.ListItem
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract
+import app.k9mail.feature.account.oauth.ui.AccountOAuthView
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.ConfigStep
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.Event
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.State
+
+internal fun LazyListScope.contentItems(
+    state: State,
+    onEvent: (Event) -> Unit,
+    oAuthViewModel: AccountOAuthContract.ViewModel,
+) {
+    if (state.configStep != ConfigStep.EMAIL_ADDRESS) {
+        item(key = "autodiscovery") {
+            AutoDiscoveryStatusItem(
+                autoDiscoverySettings = state.autoDiscoverySettings,
+                onEditConfigurationClick = { onEvent(Event.OnEditConfigurationClicked) },
+            )
+        }
+        if (state.autoDiscoverySettings != null && state.autoDiscoverySettings.isTrusted.not()) {
+            item(key = "config_approval") {
+                ConfigurationApprovalItem(
+                    approvalState = state.configurationApproved,
+                    onConfigurationApprovalChange = { onEvent(Event.ConfigurationApprovalChanged(it)) },
+                )
+            }
+        }
+    }
+
+    item(key = "email") {
+        EmailAddressItem(
+            emailAddress = state.emailAddress.value,
+            error = state.emailAddress.error,
+            onEmailAddressChange = { onEvent(Event.EmailAddressChanged(it)) },
+        )
+    }
+
+    if (state.configStep == ConfigStep.PASSWORD) {
+        item(key = "password") {
+            PasswordItem(
+                password = state.password.value,
+                error = state.password.error,
+                onPasswordChange = { onEvent(Event.PasswordChanged(it)) },
+            )
+        }
+    } else if (state.configStep == ConfigStep.OAUTH) {
+        item(key = "oauth") {
+            ListItem {
+                AccountOAuthView(
+                    onOAuthResult = { result -> onEvent(Event.OnOAuthResult(result)) },
+                    viewModel = oAuthViewModel,
+                )
+            }
+        }
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/item/EmailAddressItem.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/item/EmailAddressItem.kt
new file mode 100644
index 0000000000000000000000000000000000000000..6e4d13b586fb77ec79234cf8d6a7ea38c63edce5
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/item/EmailAddressItem.kt
@@ -0,0 +1,34 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery.item
+
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.lazy.LazyItemScope
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.ui.compose.designsystem.molecule.input.EmailAddressInput
+import app.k9mail.feature.account.common.ui.item.ListItem
+import app.k9mail.feature.account.setup.ui.common.toResourceString
+
+@Composable
+internal fun LazyItemScope.EmailAddressItem(
+    emailAddress: String,
+    error: ValidationError?,
+    onEmailAddressChange: (String) -> Unit,
+    modifier: Modifier = Modifier,
+    isEnabled: Boolean = true,
+) {
+    val resources = LocalContext.current.resources
+
+    ListItem(
+        modifier = modifier,
+    ) {
+        EmailAddressInput(
+            emailAddress = emailAddress,
+            errorMessage = error?.toResourceString(resources),
+            onEmailAddressChange = onEmailAddressChange,
+            isEnabled = isEnabled,
+            contentPadding = PaddingValues(),
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/item/PasswordItem.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/item/PasswordItem.kt
new file mode 100644
index 0000000000000000000000000000000000000000..a606f9d483a1299724e11bd40cebc645e0f816b2
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/item/PasswordItem.kt
@@ -0,0 +1,32 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery.item
+
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.lazy.LazyItemScope
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.ui.compose.designsystem.molecule.input.PasswordInput
+import app.k9mail.feature.account.common.ui.item.ListItem
+import app.k9mail.feature.account.setup.ui.common.toResourceString
+
+@Composable
+internal fun LazyItemScope.PasswordItem(
+    password: String,
+    error: ValidationError?,
+    onPasswordChange: (String) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val resources = LocalContext.current.resources
+
+    ListItem(
+        modifier = modifier,
+    ) {
+        PasswordInput(
+            password = password,
+            errorMessage = error?.toResourceString(resources),
+            onPasswordChange = onPasswordChange,
+            contentPadding = PaddingValues(),
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/AutoDiscoveryServerSettingsView.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/AutoDiscoveryServerSettingsView.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d20b0748fb4040567fe9064b01fcd7cef316a683
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/AutoDiscoveryServerSettingsView.kt
@@ -0,0 +1,174 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery.view
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.withStyle
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.autodiscovery.api.ConnectionSecurity
+import app.k9mail.core.common.net.Hostname
+import app.k9mail.core.common.net.isIpAddress
+import app.k9mail.core.common.net.toHostname
+import app.k9mail.core.ui.compose.designsystem.atom.Icon
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextBody1
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextBody2
+import app.k9mail.core.ui.compose.theme.Icons
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+import app.k9mail.feature.account.setup.ui.autodiscovery.toResourceString
+import app.k9mail.feature.account.setup.ui.common.toResourceString
+
+@Composable
+internal fun AutoDiscoveryServerSettingsView(
+    protocolName: String,
+    serverHostname: Hostname,
+    serverPort: Int,
+    connectionSecurity: ConnectionSecurity,
+    modifier: Modifier = Modifier,
+    username: String = "",
+    isIncoming: Boolean = true,
+) {
+    val resources = LocalContext.current.resources
+    Column(
+        verticalArrangement = Arrangement.spacedBy(MainTheme.spacings.default),
+        modifier = modifier,
+    ) {
+        TextBody1(
+            text = buildAnnotatedString {
+                append(if (isIncoming) "Incoming" else "Outgoing")
+                append(" ")
+                withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+                    append(protocolName.uppercase())
+                }
+                append(" ")
+                append("configuration")
+            },
+        )
+
+        ServerSettingRow(
+            icon = if (isIncoming) Icons.Filled.inbox else Icons.Filled.outbox,
+            text = buildAnnotatedString {
+                append("Server")
+                append(": ")
+                if (serverHostname.isIpAddress()) {
+                    append(serverHostname.value)
+                } else {
+                    append(serverHostname.value.substringBefore(".") + ".")
+                    withStyle(style = SpanStyle(fontWeight = FontWeight.Bold)) {
+                        append(serverHostname.value.substringAfter("."))
+                    }
+                }
+                append(":$serverPort")
+            },
+        )
+
+        ServerSettingRow(
+            icon = Icons.Filled.security,
+            text = buildAnnotatedString {
+                append("Security: ")
+                append(connectionSecurity.toResourceString(resources))
+            },
+        )
+
+        if (username.isNotEmpty()) {
+            ServerSettingRow(
+                icon = Icons.Filled.user,
+                text = buildAnnotatedString {
+                    append("Username: ")
+                    append(username)
+                },
+            )
+        }
+    }
+}
+
+@Composable
+private fun ServerSettingRow(
+    icon: ImageVector,
+    text: AnnotatedString,
+    modifier: Modifier = Modifier,
+    showIcon: Boolean = false,
+) {
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .then(modifier),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        if (showIcon) {
+            Icon(
+                imageVector = icon,
+                modifier = Modifier.padding(end = MainTheme.spacings.default),
+            )
+        }
+        TextBody2(
+            text = text,
+        )
+    }
+}
+
+@Preview
+@Composable
+internal fun AutoDiscoveryServerSettingsViewPreview() {
+    PreviewWithThemes {
+        AutoDiscoveryServerSettingsView(
+            protocolName = "IMAP",
+            serverHostname = "imap.example.com".toHostname(),
+            serverPort = 993,
+            connectionSecurity = ConnectionSecurity.TLS,
+        )
+    }
+}
+
+@Preview
+@Composable
+internal fun AutoDiscoveryServerSettingsViewOutgoingPreview() {
+    PreviewWithThemes {
+        AutoDiscoveryServerSettingsView(
+            protocolName = "IMAP",
+            serverHostname = "imap.example.com".toHostname(),
+            serverPort = 993,
+            connectionSecurity = ConnectionSecurity.TLS,
+            isIncoming = false,
+        )
+    }
+}
+
+@Preview
+@Composable
+internal fun AutoDiscoveryServerSettingsViewWithUserPreview() {
+    PreviewWithThemes {
+        AutoDiscoveryServerSettingsView(
+            protocolName = "IMAP",
+            serverHostname = "imap.example.com".toHostname(),
+            serverPort = 993,
+            connectionSecurity = ConnectionSecurity.TLS,
+            username = "username",
+        )
+    }
+}
+
+@Preview
+@Composable
+internal fun AutoDiscoveryServerSettingsViewWithIpAddressPreview() {
+    PreviewWithThemes {
+        AutoDiscoveryServerSettingsView(
+            protocolName = "IMAP",
+            serverHostname = "127.0.0.1".toHostname(),
+            serverPort = 993,
+            connectionSecurity = ConnectionSecurity.TLS,
+            username = "username",
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/AutoDiscoveryStatusBodyView.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/AutoDiscoveryStatusBodyView.kt
new file mode 100644
index 0000000000000000000000000000000000000000..a037618f5e239da126641891e676a12f6c464f21
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/AutoDiscoveryStatusBodyView.kt
@@ -0,0 +1,134 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery.view
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.autodiscovery.api.AuthenticationType
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.autodiscovery.api.ConnectionSecurity
+import app.k9mail.autodiscovery.api.ImapServerSettings
+import app.k9mail.autodiscovery.api.SmtpServerSettings
+import app.k9mail.core.common.net.toHostname
+import app.k9mail.core.common.net.toPort
+import app.k9mail.core.ui.compose.designsystem.atom.button.ButtonText
+import app.k9mail.core.ui.compose.designsystem.atom.button.buttonContentPadding
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextBody2
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+import app.k9mail.feature.account.setup.R
+
+@Composable
+internal fun AutoDiscoveryStatusBodyView(
+    settings: AutoDiscoveryResult.Settings,
+    onEditConfigurationClick: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    Column(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(horizontal = MainTheme.spacings.default)
+            .then(modifier),
+        verticalArrangement = Arrangement.spacedBy(MainTheme.spacings.default),
+    ) {
+        if (settings.isTrusted.not()) {
+            Spacer(modifier = Modifier.height(MainTheme.sizes.smaller))
+            TextBody2(
+                text = stringResource(
+                    id = R.string.account_setup_auto_config_status_disclaimer_untrusted_configuration,
+                ),
+                modifier = Modifier.fillMaxWidth(),
+            )
+        }
+
+        val incomingServerSettings = settings.incomingServerSettings
+        if (incomingServerSettings is ImapServerSettings) {
+            Spacer(modifier = Modifier.height(MainTheme.sizes.smaller))
+            AutoDiscoveryServerSettingsView(
+                protocolName = "IMAP",
+                serverHostname = incomingServerSettings.hostname,
+                serverPort = incomingServerSettings.port.value,
+                connectionSecurity = incomingServerSettings.connectionSecurity,
+                username = incomingServerSettings.username,
+                isIncoming = true,
+                modifier = Modifier.fillMaxWidth(),
+            )
+        }
+
+        val outgoingServerSettings = settings.outgoingServerSettings
+        if (outgoingServerSettings is SmtpServerSettings) {
+            Spacer(modifier = Modifier.height(MainTheme.sizes.smaller))
+            AutoDiscoveryServerSettingsView(
+                protocolName = "SMTP",
+                serverHostname = outgoingServerSettings.hostname,
+                serverPort = outgoingServerSettings.port.value,
+                connectionSecurity = outgoingServerSettings.connectionSecurity,
+                username = outgoingServerSettings.username,
+                isIncoming = false,
+                modifier = Modifier.fillMaxWidth(),
+            )
+        }
+
+        EditConfigurationButton(
+            onEditConfigurationClick = onEditConfigurationClick,
+        )
+    }
+}
+
+@Composable
+internal fun EditConfigurationButton(
+    modifier: Modifier = Modifier,
+    onEditConfigurationClick: () -> Unit,
+) {
+    Row(
+        horizontalArrangement = Arrangement.End,
+        modifier = Modifier
+            .fillMaxWidth()
+            .then(modifier),
+    ) {
+        ButtonText(
+            text = stringResource(id = R.string.account_setup_auto_config_status_edit_configuration_button_label),
+            onClick = onEditConfigurationClick,
+            color = MainTheme.colors.warning,
+            contentPadding = buttonContentPadding(
+                start = MainTheme.spacings.double,
+                end = MainTheme.spacings.double,
+            ),
+        )
+    }
+}
+
+@Preview
+@Composable
+internal fun AutoDiscoveryStatusBodyViewPreview() {
+    PreviewWithThemes {
+        AutoDiscoveryStatusBodyView(
+            settings = AutoDiscoveryResult.Settings(
+                incomingServerSettings = ImapServerSettings(
+                    hostname = "imap.example.com".toHostname(),
+                    port = 993.toPort(),
+                    connectionSecurity = ConnectionSecurity.TLS,
+                    authenticationTypes = listOf(AuthenticationType.PasswordEncrypted),
+                    username = "",
+                ),
+                outgoingServerSettings = SmtpServerSettings(
+                    hostname = "smtp.example.com".toHostname(),
+                    port = 465.toPort(),
+                    connectionSecurity = ConnectionSecurity.TLS,
+                    authenticationTypes = listOf(AuthenticationType.PasswordEncrypted),
+                    username = "",
+                ),
+                isTrusted = true,
+                source = "preview",
+            ),
+            onEditConfigurationClick = {},
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/AutoDiscoveryStatusHeaderState.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/AutoDiscoveryStatusHeaderState.kt
new file mode 100644
index 0000000000000000000000000000000000000000..de36f44fcc2d36e64280c2fd5121fb49431f5615
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/AutoDiscoveryStatusHeaderState.kt
@@ -0,0 +1,34 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery.view
+
+import androidx.annotation.StringRes
+import androidx.compose.ui.graphics.vector.ImageVector
+import app.k9mail.core.ui.compose.theme.Icons
+import app.k9mail.feature.account.setup.R
+
+enum class AutoDiscoveryStatusHeaderState(
+    val icon: ImageVector,
+    @StringRes val titleResourceId: Int,
+    @StringRes val subtitleResourceId: Int,
+    val isExpandable: Boolean,
+) {
+    NoSettings(
+        icon = Icons.Outlined.info,
+        titleResourceId = R.string.account_setup_auto_config_status_header_title_configuration_not_found,
+        subtitleResourceId = R.string.account_setup_auto_config_status_header_subtitle_configuration_not_found,
+        isExpandable = false,
+    ),
+
+    Trusted(
+        icon = Icons.Outlined.check,
+        titleResourceId = R.string.account_setup_auto_config_status_header_title_configuration_found,
+        subtitleResourceId = R.string.account_setup_auto_config_status_header_subtitle_configuration_trusted,
+        isExpandable = true,
+    ),
+
+    Untrusted(
+        icon = Icons.Outlined.info,
+        titleResourceId = R.string.account_setup_auto_config_status_header_title_configuration_found,
+        subtitleResourceId = R.string.account_setup_auto_config_status_header_subtitle_configuration_untrusted,
+        isExpandable = true,
+    ),
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/AutoDiscoveryStatusHeaderView.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/AutoDiscoveryStatusHeaderView.kt
new file mode 100644
index 0000000000000000000000000000000000000000..31c5906027b294db23b00ff476ec414681fc1bc1
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/AutoDiscoveryStatusHeaderView.kt
@@ -0,0 +1,129 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery.view
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.requiredSize
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.Preview
+import app.k9mail.core.ui.compose.designsystem.atom.Icon
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextBody2
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline6
+import app.k9mail.core.ui.compose.theme.Icons
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+
+@Suppress("LongMethod")
+@Composable
+internal fun AutoDiscoveryStatusHeaderView(
+    state: AutoDiscoveryStatusHeaderState,
+    isExpanded: Boolean,
+    modifier: Modifier = Modifier,
+) {
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .then(modifier),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Icon(
+            imageVector = state.icon,
+            tint = selectColor(state),
+            modifier = Modifier
+                .padding(MainTheme.spacings.default)
+                .requiredSize(MainTheme.sizes.medium),
+        )
+        Column(
+            modifier = Modifier
+                .weight(1f)
+                .padding(
+                    start = MainTheme.spacings.default,
+                    top = MainTheme.spacings.half,
+                    bottom = MainTheme.spacings.half,
+                ),
+        ) {
+            TextHeadline6(
+                text = stringResource(state.titleResourceId),
+            )
+            TextBody2(
+                text = stringResource(state.subtitleResourceId),
+                color = selectColor(state),
+            )
+        }
+        if (state.isExpandable) {
+            Icon(
+                imageVector = if (isExpanded) Icons.Outlined.expandLess else Icons.Outlined.expandMore,
+                modifier = Modifier.padding(MainTheme.spacings.default),
+            )
+        }
+    }
+}
+
+@Composable
+private fun selectColor(state: AutoDiscoveryStatusHeaderState): Color {
+    return when (state) {
+        AutoDiscoveryStatusHeaderState.NoSettings -> MainTheme.colors.primary
+        AutoDiscoveryStatusHeaderState.Trusted -> MainTheme.colors.success
+        AutoDiscoveryStatusHeaderState.Untrusted -> MainTheme.colors.warning
+    }
+}
+
+@Preview
+@Composable
+internal fun AutoDiscoveryStatusHeaderViewTrustedCollapsedPreview() {
+    PreviewWithThemes {
+        AutoDiscoveryStatusHeaderView(
+            state = AutoDiscoveryStatusHeaderState.Trusted,
+            isExpanded = true,
+        )
+    }
+}
+
+@Preview
+@Composable
+internal fun AutoDiscoveryStatusHeaderViewTrustedExpandedPreview() {
+    PreviewWithThemes {
+        AutoDiscoveryStatusHeaderView(
+            state = AutoDiscoveryStatusHeaderState.Trusted,
+            isExpanded = false,
+        )
+    }
+}
+
+@Preview
+@Composable
+internal fun AutoDiscoveryStatusHeaderViewUntrustedCollapsedPreview() {
+    PreviewWithThemes {
+        AutoDiscoveryStatusHeaderView(
+            state = AutoDiscoveryStatusHeaderState.Untrusted,
+            isExpanded = true,
+        )
+    }
+}
+
+@Preview
+@Composable
+internal fun AutoDiscoveryStatusHeaderViewUntrustedExpandedPreview() {
+    PreviewWithThemes {
+        AutoDiscoveryStatusHeaderView(
+            state = AutoDiscoveryStatusHeaderState.Untrusted,
+            isExpanded = false,
+        )
+    }
+}
+
+@Preview
+@Composable
+internal fun AutoDiscoveryStatusHeaderNoSettingsPreview() {
+    PreviewWithThemes {
+        AutoDiscoveryStatusHeaderView(
+            state = AutoDiscoveryStatusHeaderState.NoSettings,
+            isExpanded = false,
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/AutoDiscoveryStatusView.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/AutoDiscoveryStatusView.kt
new file mode 100644
index 0000000000000000000000000000000000000000..4d840f2b9fbf34854e2737b888947f646c3720bf
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/AutoDiscoveryStatusView.kt
@@ -0,0 +1,128 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery.view
+
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.foundation.border
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import app.k9mail.autodiscovery.api.AuthenticationType
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.autodiscovery.api.ConnectionSecurity
+import app.k9mail.autodiscovery.api.ImapServerSettings
+import app.k9mail.autodiscovery.api.SmtpServerSettings
+import app.k9mail.core.common.net.toHostname
+import app.k9mail.core.common.net.toPort
+import app.k9mail.core.ui.compose.designsystem.atom.Surface
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+
+@Composable
+internal fun AutoDiscoveryStatusView(
+    settings: AutoDiscoveryResult.Settings?,
+    onEditConfigurationClick: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val expanded = remember { mutableStateOf(false) }
+
+    Column(
+        modifier = modifier,
+    ) {
+        Surface(
+            shape = MainTheme.shapes.small,
+            modifier = Modifier
+                .border(
+                    width = 1.dp,
+                    color = Color.Gray.copy(alpha = 0.5f),
+                    shape = MainTheme.shapes.small,
+                )
+                .clickable { expanded.value = !expanded.value },
+        ) {
+            Column(
+                modifier = Modifier.padding(MainTheme.spacings.default),
+            ) {
+                AutoDiscoveryStatusHeaderView(
+                    state = if (settings == null) {
+                        AutoDiscoveryStatusHeaderState.NoSettings
+                    } else if (settings.isTrusted) {
+                        AutoDiscoveryStatusHeaderState.Trusted
+                    } else {
+                        AutoDiscoveryStatusHeaderState.Untrusted
+                    },
+                    isExpanded = expanded.value,
+                )
+
+                if (settings != null) {
+                    AnimatedVisibility(visible = expanded.value) {
+                        AutoDiscoveryStatusBodyView(
+                            settings = settings,
+                            onEditConfigurationClick = onEditConfigurationClick,
+                        )
+                    }
+                }
+            }
+        }
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun AutoDiscoveryStatusViewTrustedPreview() {
+    PreviewWithThemes {
+        AutoDiscoveryStatusView(
+            settings = AutoDiscoveryResult.Settings(
+                incomingServerSettings = ImapServerSettings(
+                    hostname = "imap.example.com".toHostname(),
+                    port = 993.toPort(),
+                    connectionSecurity = ConnectionSecurity.TLS,
+                    authenticationTypes = listOf(AuthenticationType.PasswordEncrypted),
+                    username = "",
+                ),
+                outgoingServerSettings = SmtpServerSettings(
+                    hostname = "smtp.example.com".toHostname(),
+                    port = 465.toPort(),
+                    connectionSecurity = ConnectionSecurity.TLS,
+                    authenticationTypes = listOf(AuthenticationType.PasswordEncrypted),
+                    username = "",
+                ),
+                isTrusted = true,
+                source = "preview",
+            ),
+            onEditConfigurationClick = {},
+        )
+    }
+}
+
+@Preview(showBackground = true)
+@Composable
+internal fun AutoDiscoveryStatusViewUntrustedPreview() {
+    PreviewWithThemes {
+        AutoDiscoveryStatusView(
+            settings = AutoDiscoveryResult.Settings(
+                incomingServerSettings = ImapServerSettings(
+                    hostname = "imap.example.com".toHostname(),
+                    port = 993.toPort(),
+                    connectionSecurity = ConnectionSecurity.TLS,
+                    authenticationTypes = listOf(AuthenticationType.PasswordEncrypted),
+                    username = "",
+                ),
+                outgoingServerSettings = SmtpServerSettings(
+                    hostname = "smtp.example.com".toHostname(),
+                    port = 465.toPort(),
+                    connectionSecurity = ConnectionSecurity.TLS,
+                    authenticationTypes = listOf(AuthenticationType.PasswordEncrypted),
+                    username = "",
+                ),
+                isTrusted = false,
+                source = "preview",
+            ),
+            onEditConfigurationClick = {},
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/ConfigurationApprovalView.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/ConfigurationApprovalView.kt
new file mode 100644
index 0000000000000000000000000000000000000000..2bd6c81b27df2fdd9e22907afedfe0b8351fa199
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/view/ConfigurationApprovalView.kt
@@ -0,0 +1,34 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery.view
+
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.height
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import app.k9mail.core.ui.compose.designsystem.molecule.input.CheckboxInput
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.feature.account.setup.R
+import app.k9mail.feature.account.setup.domain.input.BooleanInputField
+import app.k9mail.feature.account.setup.ui.autodiscovery.toResourceString
+
+@Composable
+internal fun ConfigurationApprovalView(
+    approvalState: BooleanInputField,
+    onConfigurationApprovalChange: (Boolean) -> Unit,
+) {
+    val resources = LocalContext.current.resources
+
+    Spacer(modifier = Modifier.height(MainTheme.spacings.default))
+
+    CheckboxInput(
+        text = stringResource(
+            id = R.string.account_setup_auto_config_status_checkbox_configuration_untrusted_confirmation_label,
+        ),
+        checked = approvalState.value ?: false,
+        onCheckedChange = onConfigurationApprovalChange,
+        errorMessage = approvalState.error?.toResourceString(resources),
+        contentPadding = PaddingValues(),
+    )
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/clientcertificate/ClientCertificateInput.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/clientcertificate/ClientCertificateInput.kt
new file mode 100644
index 0000000000000000000000000000000000000000..694b0421bd72bfd43c05d5bd28985294c0340650
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/clientcertificate/ClientCertificateInput.kt
@@ -0,0 +1,40 @@
+package app.k9mail.feature.account.setup.ui.clientcertificate
+
+import android.security.KeyChain
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import app.k9mail.core.ui.compose.common.activity.LocalActivity
+import app.k9mail.core.ui.compose.designsystem.atom.textfield.TextFieldOutlinedFakeSelect
+import app.k9mail.core.ui.compose.designsystem.molecule.input.inputContentPadding
+import app.k9mail.feature.account.setup.R
+
+@Composable
+fun ClientCertificateInput(
+    alias: String?,
+    onValueChange: (String?) -> Unit,
+    modifier: Modifier = Modifier,
+    label: String? = null,
+    contentPadding: PaddingValues = inputContentPadding(),
+) {
+    Column(
+        modifier = Modifier
+            .padding(contentPadding)
+            .fillMaxWidth()
+            .then(modifier),
+    ) {
+        val activity = LocalActivity.current
+        TextFieldOutlinedFakeSelect(
+            text = alias ?: stringResource(R.string.account_setup_client_certificate_none_selected),
+            onClick = {
+                KeyChain.choosePrivateKeyAlias(activity, onValueChange, null, null, null, -1, alias)
+            },
+            modifier = Modifier.fillMaxWidth(),
+            label = label,
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/common/AccountSetupStringMapper.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/common/AccountSetupStringMapper.kt
new file mode 100644
index 0000000000000000000000000000000000000000..15b40d767ac552ea291c8c26232fdc159d1db753
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/common/AccountSetupStringMapper.kt
@@ -0,0 +1,88 @@
+package app.k9mail.feature.account.setup.ui.common
+
+import android.content.res.Resources
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.feature.account.setup.R
+import app.k9mail.feature.account.setup.domain.entity.ConnectionSecurity
+import app.k9mail.feature.account.setup.domain.usecase.ValidateEmailAddress.ValidateEmailAddressError
+import app.k9mail.feature.account.setup.domain.usecase.ValidateImapPrefix.ValidateImapPrefixError
+import app.k9mail.feature.account.setup.domain.usecase.ValidatePassword.ValidatePasswordError
+import app.k9mail.feature.account.setup.domain.usecase.ValidatePort.ValidatePortError
+import app.k9mail.feature.account.setup.domain.usecase.ValidateServer.ValidateServerError
+import app.k9mail.feature.account.setup.domain.usecase.ValidateUsername.ValidateUsernameError
+
+internal fun ConnectionSecurity.toResourceString(resources: Resources): String {
+    return when (this) {
+        ConnectionSecurity.None -> resources.getString(R.string.account_setup_connection_security_none)
+        ConnectionSecurity.StartTLS -> resources.getString(R.string.account_setup_connection_security_start_tls)
+        ConnectionSecurity.TLS -> resources.getString(R.string.account_setup_connection_security_ssl)
+    }
+}
+
+internal fun ValidationError.toResourceString(resources: Resources): String {
+    return when (this) {
+        is ValidateEmailAddressError -> toEmailAddressErrorString(resources)
+        is ValidateServerError -> toServerErrorString(resources)
+        is ValidatePortError -> toPortErrorString(resources)
+        is ValidateUsernameError -> toUsernameErrorString(resources)
+        is ValidatePasswordError -> toPasswordErrorString(resources)
+        is ValidateImapPrefixError -> toImapPrefixErrorString(resources)
+        else -> throw IllegalArgumentException("Unknown error: $this")
+    }
+}
+
+private fun ValidateEmailAddressError.toEmailAddressErrorString(resources: Resources): String {
+    return when (this) {
+        is ValidateEmailAddressError.EmptyEmailAddress -> resources.getString(
+            R.string.account_setup_validation_error_email_address_required,
+        )
+
+        is ValidateEmailAddressError.InvalidEmailAddress -> resources.getString(
+            R.string.account_setup_validation_error_email_address_invalid,
+        )
+    }
+}
+
+private fun ValidateServerError.toServerErrorString(resources: Resources): String {
+    return when (this) {
+        is ValidateServerError.EmptyServer -> resources.getString(
+            R.string.account_setup_validation_error_server_required,
+        )
+    }
+}
+
+private fun ValidatePortError.toPortErrorString(resources: Resources): String {
+    return when (this) {
+        is ValidatePortError.EmptyPort -> resources.getString(
+            R.string.account_setup_validation_error_port_required,
+        )
+
+        is ValidatePortError.InvalidPort -> resources.getString(
+            R.string.account_setup_validation_error_port_invalid,
+        )
+    }
+}
+
+private fun ValidateUsernameError.toUsernameErrorString(resources: Resources): String {
+    return when (this) {
+        ValidateUsernameError.EmptyUsername -> resources.getString(
+            R.string.account_setup_validation_error_username_required,
+        )
+    }
+}
+
+private fun ValidatePasswordError.toPasswordErrorString(resources: Resources): String {
+    return when (this) {
+        ValidatePasswordError.EmptyPassword -> resources.getString(
+            R.string.account_setup_validation_error_password_required,
+        )
+    }
+}
+
+private fun ValidateImapPrefixError.toImapPrefixErrorString(resources: Resources): String {
+    return when (this) {
+        ValidateImapPrefixError.BlankImapPrefix -> resources.getString(
+            R.string.account_setup_validation_error_imap_prefix_blank,
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/common/AccountSetupTopAppBar.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/common/AccountSetupTopAppBar.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c5f07c409357e3fc40aef365e255d6af87970a4a
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/common/AccountSetupTopAppBar.kt
@@ -0,0 +1,44 @@
+package app.k9mail.feature.account.setup.ui.common
+
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.res.stringResource
+import app.k9mail.core.ui.compose.common.DevicePreviews
+import app.k9mail.core.ui.compose.designsystem.organism.TopAppBar
+import app.k9mail.core.ui.compose.theme.K9Theme
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
+import app.k9mail.feature.account.setup.R.string
+
+@Composable
+internal fun AccountSetupTopAppBar(
+    title: String,
+) {
+    TopAppBar(
+        title = title,
+        subtitle = stringResource(id = string.account_setup_title),
+        titleContentPadding = PaddingValues(
+            start = MainTheme.spacings.double,
+        ),
+    )
+}
+
+@DevicePreviews
+@Composable
+internal fun AccountSetupTopAppBarK9Preview() {
+    K9Theme {
+        AccountSetupTopAppBar(
+            title = "Title",
+        )
+    }
+}
+
+@DevicePreviews
+@Composable
+internal fun AccountSetupTopAppBarThunderbirdPreview() {
+    ThunderbirdTheme {
+        AccountSetupTopAppBar(
+            title = "Title",
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/common/mapper/AuthenticationTypeStringMapper.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/common/mapper/AuthenticationTypeStringMapper.kt
new file mode 100644
index 0000000000000000000000000000000000000000..cc6e28ce9cc78dc8bdf8c35239d907f922a75ae4
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/common/mapper/AuthenticationTypeStringMapper.kt
@@ -0,0 +1,25 @@
+package app.k9mail.feature.account.setup.ui.common.mapper
+
+import android.content.res.Resources
+import app.k9mail.feature.account.setup.R
+import app.k9mail.feature.account.setup.domain.entity.AuthenticationType
+
+internal fun AuthenticationType.toResourceString(resources: Resources): String {
+    return when (this) {
+        AuthenticationType.None -> {
+            resources.getString(R.string.account_setup_authentication_none)
+        }
+        AuthenticationType.PasswordCleartext -> {
+            resources.getString(R.string.account_setup_authentication_password_cleartext)
+        }
+        AuthenticationType.PasswordEncrypted -> {
+            resources.getString(R.string.account_setup_authentication_password_encrypted)
+        }
+        AuthenticationType.ClientCertificate -> {
+            resources.getString(R.string.account_setup_authentication_client_certificate)
+        }
+        AuthenticationType.OAuth2 -> {
+            resources.getString(R.string.account_setup_authentication_client_oauth)
+        }
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigContent.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigContent.kt
new file mode 100644
index 0000000000000000000000000000000000000000..620c230a6cd56cab119f5cb1b649a4d7e2bc0ec0
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigContent.kt
@@ -0,0 +1,221 @@
+package app.k9mail.feature.account.setup.ui.incoming
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.imePadding
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.requiredHeight
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.stringResource
+import app.k9mail.core.ui.compose.common.DevicePreviews
+import app.k9mail.core.ui.compose.designsystem.molecule.input.CheckboxInput
+import app.k9mail.core.ui.compose.designsystem.molecule.input.NumberInput
+import app.k9mail.core.ui.compose.designsystem.molecule.input.PasswordInput
+import app.k9mail.core.ui.compose.designsystem.molecule.input.SelectInput
+import app.k9mail.core.ui.compose.designsystem.molecule.input.TextInput
+import app.k9mail.core.ui.compose.designsystem.template.ResponsiveWidthContainer
+import app.k9mail.core.ui.compose.theme.K9Theme
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
+import app.k9mail.feature.account.common.ui.item.defaultItemPadding
+import app.k9mail.feature.account.setup.R
+import app.k9mail.feature.account.setup.domain.entity.ConnectionSecurity
+import app.k9mail.feature.account.setup.domain.entity.IncomingProtocolType
+import app.k9mail.feature.account.setup.ui.clientcertificate.ClientCertificateInput
+import app.k9mail.feature.account.setup.ui.common.mapper.toResourceString
+import app.k9mail.feature.account.setup.ui.common.toResourceString
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.Event
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.State
+
+@Suppress("LongMethod")
+@Composable
+internal fun AccountIncomingConfigContent(
+    state: State,
+    onEvent: (Event) -> Unit,
+    contentPadding: PaddingValues,
+    modifier: Modifier = Modifier,
+) {
+    val resources = LocalContext.current.resources
+
+    ResponsiveWidthContainer(
+        modifier = Modifier
+            .testTag("AccountIncomingConfigContent")
+            .padding(contentPadding)
+            .fillMaxWidth()
+            .then(modifier),
+    ) {
+        LazyColumn(
+            modifier = Modifier
+                .fillMaxSize()
+                .imePadding(),
+            horizontalAlignment = Alignment.Start,
+            verticalArrangement = Arrangement.spacedBy(MainTheme.spacings.default),
+        ) {
+            item {
+                Spacer(modifier = Modifier.requiredHeight(MainTheme.sizes.smaller))
+            }
+
+            item {
+                SelectInput(
+                    options = IncomingProtocolType.all(),
+                    selectedOption = state.protocolType,
+                    onOptionChange = { onEvent(Event.ProtocolTypeChanged(it)) },
+                    label = stringResource(id = R.string.account_setup_incoming_config_protocol_type_label),
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+
+            item {
+                TextInput(
+                    text = state.server.value,
+                    errorMessage = state.server.error?.toResourceString(resources),
+                    onTextChange = { onEvent(Event.ServerChanged(it)) },
+                    label = stringResource(id = R.string.account_setup_incoming_config_server_label),
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+
+            item {
+                SelectInput(
+                    options = ConnectionSecurity.all(),
+                    optionToStringTransformation = { it.toResourceString(resources) },
+                    selectedOption = state.security,
+                    onOptionChange = { onEvent(Event.SecurityChanged(it)) },
+                    label = stringResource(id = R.string.account_setup_incoming_config_security_label),
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+
+            item {
+                NumberInput(
+                    value = state.port.value,
+                    errorMessage = state.port.error?.toResourceString(resources),
+                    onValueChange = { onEvent(Event.PortChanged(it)) },
+                    label = stringResource(id = R.string.account_setup_outgoing_config_port_label),
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+
+            item {
+                SelectInput(
+                    options = state.allowedAuthenticationTypes,
+                    optionToStringTransformation = { it.toResourceString(resources) },
+                    selectedOption = state.authenticationType,
+                    onOptionChange = { onEvent(Event.AuthenticationTypeChanged(it)) },
+                    label = stringResource(id = R.string.account_setup_incoming_config_authentication_label),
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+
+            item {
+                TextInput(
+                    text = state.username.value,
+                    errorMessage = state.username.error?.toResourceString(resources),
+                    onTextChange = { onEvent(Event.UsernameChanged(it)) },
+                    label = stringResource(id = R.string.account_setup_outgoing_config_username_label),
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+
+            if (state.isPasswordFieldVisible) {
+                item {
+                    PasswordInput(
+                        password = state.password.value,
+                        errorMessage = state.password.error?.toResourceString(resources),
+                        onPasswordChange = { onEvent(Event.PasswordChanged(it)) },
+                        contentPadding = defaultItemPadding(),
+                    )
+                }
+            }
+
+            item {
+                ClientCertificateInput(
+                    alias = state.clientCertificateAlias,
+                    onValueChange = { onEvent(Event.ClientCertificateChanged(it)) },
+                    label = stringResource(id = R.string.account_setup_client_certificate_label),
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+
+            if (state.protocolType == IncomingProtocolType.IMAP) {
+                item {
+                    CheckboxInput(
+                        text = stringResource(id = R.string.account_setup_incoming_config_imap_namespace_label),
+                        checked = state.imapAutodetectNamespaceEnabled,
+                        onCheckedChange = { onEvent(Event.ImapAutoDetectNamespaceChanged(it)) },
+                        contentPadding = defaultItemPadding(),
+                    )
+                }
+
+                item {
+                    if (state.imapAutodetectNamespaceEnabled) {
+                        TextInput(
+                            onTextChange = {},
+                            label = stringResource(id = R.string.account_setup_incoming_config_imap_prefix_label),
+                            contentPadding = defaultItemPadding(),
+                            isEnabled = false,
+                        )
+                    } else {
+                        TextInput(
+                            text = state.imapPrefix.value,
+                            errorMessage = state.imapPrefix.error?.toResourceString(resources),
+                            onTextChange = { onEvent(Event.ImapPrefixChanged(it)) },
+                            label = stringResource(id = R.string.account_setup_incoming_config_imap_prefix_label),
+                            contentPadding = defaultItemPadding(),
+                        )
+                    }
+                }
+
+                item {
+                    CheckboxInput(
+                        text = stringResource(id = R.string.account_setup_incoming_config_imap_compression_label),
+                        checked = state.imapUseCompression,
+                        onCheckedChange = { onEvent(Event.ImapUseCompressionChanged(it)) },
+                        contentPadding = defaultItemPadding(),
+                    )
+                }
+
+                item {
+                    CheckboxInput(
+                        text = stringResource(R.string.account_setup_incoming_config_imap_send_client_id_label),
+                        checked = state.imapSendClientId,
+                        onCheckedChange = { onEvent(Event.ImapSendClientIdChanged(it)) },
+                        contentPadding = defaultItemPadding(),
+                    )
+                }
+            }
+        }
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountIncomingConfigContentK9Preview() {
+    K9Theme {
+        AccountIncomingConfigContent(
+            onEvent = { },
+            state = State(),
+            contentPadding = PaddingValues(),
+        )
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountIncomingConfigContentThunderbirdPreview() {
+    ThunderbirdTheme {
+        AccountIncomingConfigContent(
+            onEvent = { },
+            state = State(),
+            contentPadding = PaddingValues(),
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigContract.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigContract.kt
new file mode 100644
index 0000000000000000000000000000000000000000..403671bb96cae65cad3ccf90c28230c7b8bf678b
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigContract.kt
@@ -0,0 +1,65 @@
+package app.k9mail.feature.account.setup.ui.incoming
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.core.ui.compose.common.mvi.UnidirectionalViewModel
+import app.k9mail.feature.account.setup.domain.entity.AuthenticationType
+import app.k9mail.feature.account.setup.domain.entity.ConnectionSecurity
+import app.k9mail.feature.account.setup.domain.entity.IncomingProtocolType
+import app.k9mail.feature.account.setup.domain.entity.toDefaultPort
+import app.k9mail.feature.account.setup.domain.input.NumberInputField
+import app.k9mail.feature.account.setup.domain.input.StringInputField
+
+interface AccountIncomingConfigContract {
+
+    interface ViewModel : UnidirectionalViewModel<State, Event, Effect>
+
+    data class State(
+        val protocolType: IncomingProtocolType = IncomingProtocolType.DEFAULT,
+        val server: StringInputField = StringInputField(),
+        val security: ConnectionSecurity = IncomingProtocolType.DEFAULT.defaultConnectionSecurity,
+        val port: NumberInputField = NumberInputField(
+            IncomingProtocolType.DEFAULT.toDefaultPort(IncomingProtocolType.DEFAULT.defaultConnectionSecurity),
+        ),
+        val authenticationType: AuthenticationType = AuthenticationType.PasswordCleartext,
+        val username: StringInputField = StringInputField(),
+        val password: StringInputField = StringInputField(),
+        val clientCertificateAlias: String? = null,
+        val imapAutodetectNamespaceEnabled: Boolean = true,
+        val imapPrefix: StringInputField = StringInputField(),
+        val imapUseCompression: Boolean = true,
+        val imapSendClientId: Boolean = true,
+    )
+
+    sealed interface Event {
+        data class ProtocolTypeChanged(val protocolType: IncomingProtocolType) : Event
+        data class ServerChanged(val server: String) : Event
+        data class SecurityChanged(val security: ConnectionSecurity) : Event
+        data class PortChanged(val port: Long?) : Event
+        data class AuthenticationTypeChanged(val authenticationType: AuthenticationType) : Event
+        data class UsernameChanged(val username: String) : Event
+        data class PasswordChanged(val password: String) : Event
+        data class ClientCertificateChanged(val clientCertificateAlias: String?) : Event
+        data class ImapAutoDetectNamespaceChanged(val enabled: Boolean) : Event
+        data class ImapPrefixChanged(val imapPrefix: String) : Event
+        data class ImapUseCompressionChanged(val useCompression: Boolean) : Event
+        data class ImapSendClientIdChanged(val sendClientId: Boolean) : Event
+
+        object LoadAccountSetupState : Event
+
+        object OnNextClicked : Event
+        object OnBackClicked : Event
+    }
+
+    sealed interface Effect {
+        object NavigateNext : Effect
+        object NavigateBack : Effect
+    }
+
+    interface Validator {
+        fun validateServer(server: String): ValidationResult
+        fun validatePort(port: Long?): ValidationResult
+        fun validateUsername(username: String): ValidationResult
+        fun validatePassword(password: String): ValidationResult
+        fun validateImapPrefix(imapPrefix: String): ValidationResult
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigScreen.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigScreen.kt
new file mode 100644
index 0000000000000000000000000000000000000000..236acee88ba152f9cf48c1f73cc7d040f25c9eac
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigScreen.kt
@@ -0,0 +1,95 @@
+package app.k9mail.feature.account.setup.ui.incoming
+
+import androidx.activity.compose.BackHandler
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import app.k9mail.core.ui.compose.common.DevicePreviews
+import app.k9mail.core.ui.compose.common.mvi.observe
+import app.k9mail.core.ui.compose.designsystem.template.Scaffold
+import app.k9mail.core.ui.compose.theme.K9Theme
+import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
+import app.k9mail.feature.account.common.ui.WizardNavigationBar
+import app.k9mail.feature.account.setup.R
+import app.k9mail.feature.account.setup.ui.common.AccountSetupTopAppBar
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.Effect
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.Event
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.ViewModel
+import app.k9mail.feature.account.setup.ui.preview.PreviewAccountSetupStateRepository
+
+@Composable
+internal fun AccountIncomingConfigScreen(
+    onNext: (AccountIncomingConfigContract.State) -> Unit,
+    onBack: () -> Unit,
+    viewModel: ViewModel,
+    modifier: Modifier = Modifier,
+) {
+    val (state, dispatch) = viewModel.observe { effect ->
+        when (effect) {
+            is Effect.NavigateNext -> onNext(viewModel.state.value)
+            is Effect.NavigateBack -> onBack()
+        }
+    }
+
+    LaunchedEffect(key1 = Unit) {
+        dispatch(Event.LoadAccountSetupState)
+    }
+
+    BackHandler {
+        dispatch(Event.OnBackClicked)
+    }
+
+    Scaffold(
+        topBar = {
+            AccountSetupTopAppBar(
+                title = stringResource(id = R.string.account_setup_incoming_config_top_bar_title),
+            )
+        },
+        bottomBar = {
+            WizardNavigationBar(
+                nextButtonText = stringResource(id = R.string.account_setup_button_next),
+                backButtonText = stringResource(id = R.string.account_setup_button_back),
+                onNextClick = { dispatch(Event.OnNextClicked) },
+                onBackClick = { dispatch(Event.OnBackClicked) },
+            )
+        },
+        modifier = modifier,
+    ) { innerPadding ->
+        AccountIncomingConfigContent(
+            onEvent = { dispatch(it) },
+            state = state.value,
+            contentPadding = innerPadding,
+        )
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountIncomingConfigScreenK9Preview() {
+    K9Theme {
+        AccountIncomingConfigScreen(
+            onNext = {},
+            onBack = {},
+            viewModel = AccountIncomingConfigViewModel(
+                validator = AccountIncomingConfigValidator(),
+                accountSetupStateRepository = PreviewAccountSetupStateRepository(),
+            ),
+        )
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountIncomingConfigScreenThunderbirdPreview() {
+    ThunderbirdTheme {
+        AccountIncomingConfigScreen(
+            onNext = {},
+            onBack = {},
+            viewModel = AccountIncomingConfigViewModel(
+                validator = AccountIncomingConfigValidator(),
+                accountSetupStateRepository = PreviewAccountSetupStateRepository(),
+            ),
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigStateExtensions.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigStateExtensions.kt
new file mode 100644
index 0000000000000000000000000000000000000000..9956324bf8ae5f20afabf8c994f29a85c72e2ca3
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigStateExtensions.kt
@@ -0,0 +1,36 @@
+package app.k9mail.feature.account.setup.ui.incoming
+
+import app.k9mail.feature.account.setup.domain.entity.AuthenticationType
+import app.k9mail.feature.account.setup.domain.entity.AuthenticationType.ClientCertificate
+import app.k9mail.feature.account.setup.domain.entity.AuthenticationType.OAuth2
+import app.k9mail.feature.account.setup.domain.entity.AuthenticationType.PasswordCleartext
+import app.k9mail.feature.account.setup.domain.entity.AuthenticationType.PasswordEncrypted
+import app.k9mail.feature.account.setup.domain.entity.IncomingProtocolType
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.toImmutableList
+
+internal val AccountIncomingConfigContract.State.isPasswordFieldVisible: Boolean
+    get() = authenticationType.isPasswordRequired
+
+internal val AccountIncomingConfigContract.State.allowedAuthenticationTypes: ImmutableList<AuthenticationType>
+    get() = protocolType.allowedAuthenticationTypes.toImmutableList()
+
+internal val IncomingProtocolType.allowedAuthenticationTypes: List<AuthenticationType>
+    get() = when (this) {
+        IncomingProtocolType.IMAP -> {
+            listOf(
+                PasswordCleartext,
+                PasswordEncrypted,
+                ClientCertificate,
+                OAuth2,
+            )
+        }
+
+        IncomingProtocolType.POP3 -> {
+            listOf(
+                PasswordCleartext,
+                PasswordEncrypted,
+                ClientCertificate,
+            )
+        }
+    }
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigStateMapper.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigStateMapper.kt
new file mode 100644
index 0000000000000000000000000000000000000000..cfba40c1214aabf1ca269a762474fcd3a5e22ddf
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigStateMapper.kt
@@ -0,0 +1,67 @@
+package app.k9mail.feature.account.setup.ui.incoming
+
+import app.k9mail.feature.account.setup.domain.entity.AccountSetupState
+import app.k9mail.feature.account.setup.domain.entity.IncomingProtocolType
+import app.k9mail.feature.account.setup.domain.entity.toAuthType
+import app.k9mail.feature.account.setup.domain.entity.toAuthenticationType
+import app.k9mail.feature.account.setup.domain.entity.toConnectionSecurity
+import app.k9mail.feature.account.setup.domain.entity.toMailConnectionSecurity
+import app.k9mail.feature.account.setup.domain.input.NumberInputField
+import app.k9mail.feature.account.setup.domain.input.StringInputField
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.State
+import app.k9mail.feature.account.setup.ui.validation.AccountValidationContract
+import com.fsck.k9.mail.ServerSettings
+import com.fsck.k9.mail.store.imap.ImapStoreSettings
+
+internal fun AccountSetupState.toIncomingConfigState(): State {
+    val incomingServerSettings = incomingServerSettings
+    return if (incomingServerSettings == null) {
+        State(
+            username = StringInputField(value = emailAddress ?: ""),
+        )
+    } else {
+        State(
+            protocolType = IncomingProtocolType.fromName(incomingServerSettings.type),
+            server = StringInputField(value = incomingServerSettings.host ?: ""),
+            security = incomingServerSettings.connectionSecurity.toConnectionSecurity(),
+            port = NumberInputField(value = incomingServerSettings.port.toLong()),
+            authenticationType = incomingServerSettings.authenticationType.toAuthenticationType(),
+            username = StringInputField(value = incomingServerSettings.username),
+            password = StringInputField(value = incomingServerSettings.password ?: ""),
+        )
+    }
+}
+
+internal fun State.toServerSettings(): ServerSettings {
+    return ServerSettings(
+        type = protocolType.defaultName,
+        host = server.value,
+        port = port.value!!.toInt(),
+        connectionSecurity = security.toMailConnectionSecurity(),
+        authenticationType = authenticationType.toAuthType(),
+        username = username.value,
+        password = if (authenticationType.isPasswordRequired) password.value else null,
+        clientCertificateAlias = clientCertificateAlias,
+        extra = createExtras(),
+    )
+}
+
+private fun State.createExtras(): Map<String, String?> {
+    return if (protocolType == IncomingProtocolType.IMAP) {
+        ImapStoreSettings.createExtra(
+            autoDetectNamespace = imapAutodetectNamespaceEnabled,
+            pathPrefix = if (imapAutodetectNamespaceEnabled) null else imapPrefix.value,
+            useCompression = imapUseCompression,
+            sendClientId = imapSendClientId,
+        )
+    } else {
+        emptyMap()
+    }
+}
+
+internal fun State.toValidationState(): AccountValidationContract.State {
+    return AccountValidationContract.State(
+        serverSettings = toServerSettings(),
+        // TODO add authorization state
+    )
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigValidator.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigValidator.kt
new file mode 100644
index 0000000000000000000000000000000000000000..662e605db2a0a9da7c610a3bdd5c9dba49ae3b67
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigValidator.kt
@@ -0,0 +1,37 @@
+package app.k9mail.feature.account.setup.ui.incoming
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.DomainContract.UseCase
+import app.k9mail.feature.account.setup.domain.usecase.ValidateImapPrefix
+import app.k9mail.feature.account.setup.domain.usecase.ValidatePassword
+import app.k9mail.feature.account.setup.domain.usecase.ValidatePort
+import app.k9mail.feature.account.setup.domain.usecase.ValidateServer
+import app.k9mail.feature.account.setup.domain.usecase.ValidateUsername
+
+internal class AccountIncomingConfigValidator(
+    private val serverValidator: UseCase.ValidateServer = ValidateServer(),
+    private val portValidator: UseCase.ValidatePort = ValidatePort(),
+    private val usernameValidator: UseCase.ValidateUsername = ValidateUsername(),
+    private val passwordValidator: UseCase.ValidatePassword = ValidatePassword(),
+    private val imapPrefixValidator: UseCase.ValidateImapPrefix = ValidateImapPrefix(),
+) : AccountIncomingConfigContract.Validator {
+    override fun validateServer(server: String): ValidationResult {
+        return serverValidator.execute(server)
+    }
+
+    override fun validatePort(port: Long?): ValidationResult {
+        return portValidator.execute(port)
+    }
+
+    override fun validateUsername(username: String): ValidationResult {
+        return usernameValidator.execute(username)
+    }
+
+    override fun validatePassword(password: String): ValidationResult {
+        return passwordValidator.execute(password)
+    }
+
+    override fun validateImapPrefix(imapPrefix: String): ValidationResult {
+        return imapPrefixValidator.execute(imapPrefix)
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigViewModel.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigViewModel.kt
new file mode 100644
index 0000000000000000000000000000000000000000..bb8e09625884152e31413cf5d2dfa3cc0ef949b9
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigViewModel.kt
@@ -0,0 +1,132 @@
+package app.k9mail.feature.account.setup.ui.incoming
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.core.ui.compose.common.mvi.BaseViewModel
+import app.k9mail.feature.account.setup.domain.DomainContract
+import app.k9mail.feature.account.setup.domain.entity.ConnectionSecurity
+import app.k9mail.feature.account.setup.domain.entity.IncomingProtocolType
+import app.k9mail.feature.account.setup.domain.entity.toDefaultPort
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.Effect
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.Event
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.State
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.Validator
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.ViewModel
+
+internal class AccountIncomingConfigViewModel(
+    private val validator: Validator,
+    private val accountSetupStateRepository: DomainContract.AccountSetupStateRepository,
+    initialState: State? = null,
+) : BaseViewModel<State, Event, Effect>(
+    initialState = initialState ?: accountSetupStateRepository.getState().toIncomingConfigState(),
+),
+    ViewModel {
+
+    @Suppress("CyclomaticComplexMethod")
+    override fun event(event: Event) {
+        when (event) {
+            Event.LoadAccountSetupState -> loadAccountSetupState()
+
+            is Event.ProtocolTypeChanged -> updateProtocolType(event.protocolType)
+            is Event.ServerChanged -> updateState { it.copy(server = it.server.updateValue(event.server)) }
+            is Event.SecurityChanged -> updateSecurity(event.security)
+            is Event.PortChanged -> updateState { it.copy(port = it.port.updateValue(event.port)) }
+            is Event.AuthenticationTypeChanged -> updateState { it.copy(authenticationType = event.authenticationType) }
+            is Event.UsernameChanged -> updateState { it.copy(username = it.username.updateValue(event.username)) }
+            is Event.PasswordChanged -> updateState { it.copy(password = it.password.updateValue(event.password)) }
+            is Event.ClientCertificateChanged -> updateState {
+                it.copy(clientCertificateAlias = event.clientCertificateAlias)
+            }
+
+            is Event.ImapAutoDetectNamespaceChanged -> updateState {
+                it.copy(imapAutodetectNamespaceEnabled = event.enabled)
+            }
+
+            is Event.ImapPrefixChanged -> updateState {
+                it.copy(imapPrefix = it.imapPrefix.updateValue(event.imapPrefix))
+            }
+
+            is Event.ImapUseCompressionChanged -> updateState { it.copy(imapUseCompression = event.useCompression) }
+            is Event.ImapSendClientIdChanged -> updateState { it.copy(imapSendClientId = event.sendClientId) }
+
+            Event.OnNextClicked -> onNext()
+            Event.OnBackClicked -> onBack()
+        }
+    }
+
+    private fun loadAccountSetupState() {
+        updateState {
+            accountSetupStateRepository.getState().toIncomingConfigState()
+        }
+    }
+
+    private fun onNext() {
+        submitConfig()
+    }
+
+    private fun updateProtocolType(protocolType: IncomingProtocolType) {
+        updateState {
+            val allowedAuthenticationTypesForNewProtocol = protocolType.allowedAuthenticationTypes
+            val newAuthenticationType = if (it.authenticationType in allowedAuthenticationTypesForNewProtocol) {
+                it.authenticationType
+            } else {
+                allowedAuthenticationTypesForNewProtocol.first()
+            }
+
+            it.copy(
+                protocolType = protocolType,
+                security = protocolType.defaultConnectionSecurity,
+                port = it.port.updateValue(
+                    protocolType.toDefaultPort(protocolType.defaultConnectionSecurity),
+                ),
+                authenticationType = newAuthenticationType,
+            )
+        }
+    }
+
+    private fun updateSecurity(security: ConnectionSecurity) {
+        updateState {
+            it.copy(
+                security = security,
+                port = it.port.updateValue(it.protocolType.toDefaultPort(security)),
+            )
+        }
+    }
+
+    private fun submitConfig() = with(state.value) {
+        val serverResult = validator.validateServer(server.value)
+        val portResult = validator.validatePort(port.value)
+        val usernameResult = validator.validateUsername(username.value)
+        val passwordResult = if (authenticationType.isPasswordRequired) {
+            validator.validatePassword(password.value)
+        } else {
+            ValidationResult.Success
+        }
+        val imapPrefixResult = validator.validateImapPrefix(imapPrefix.value)
+
+        val hasError = listOf(serverResult, portResult, usernameResult, passwordResult, imapPrefixResult)
+            .any { it is ValidationResult.Failure }
+
+        updateState {
+            it.copy(
+                server = it.server.updateFromValidationResult(serverResult),
+                port = it.port.updateFromValidationResult(portResult),
+                username = it.username.updateFromValidationResult(usernameResult),
+                password = it.password.updateFromValidationResult(passwordResult),
+                imapPrefix = it.imapPrefix.updateFromValidationResult(imapPrefixResult),
+            )
+        }
+
+        if (!hasError) {
+            accountSetupStateRepository.saveIncomingServerSettings(state.value.toServerSettings())
+            navigateNext()
+        }
+    }
+
+    private fun onBack() {
+        navigateBack()
+    }
+
+    private fun navigateBack() = emitEffect(Effect.NavigateBack)
+
+    private fun navigateNext() = emitEffect(Effect.NavigateNext)
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/manualconfig/AccountManualConfigContent.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/manualconfig/AccountManualConfigContent.kt
deleted file mode 100644
index f7b58b6291b6f9d996ab77e4ff8c5ef1bb6e8be1..0000000000000000000000000000000000000000
--- a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/manualconfig/AccountManualConfigContent.kt
+++ /dev/null
@@ -1,99 +0,0 @@
-package app.k9mail.feature.account.setup.ui.manualconfig
-
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.res.stringResource
-import app.k9mail.core.ui.compose.common.DevicePreviews
-import app.k9mail.core.ui.compose.designsystem.atom.button.Button
-import app.k9mail.core.ui.compose.designsystem.atom.button.ButtonOutlined
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline5
-import app.k9mail.core.ui.compose.designsystem.template.LazyColumnWithHeaderFooter
-import app.k9mail.core.ui.compose.designsystem.template.ResponsiveContentWithBackground
-import app.k9mail.core.ui.compose.theme.K9Theme
-import app.k9mail.core.ui.compose.theme.MainTheme
-import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
-import app.k9mail.feature.account.setup.R
-
-@Composable
-internal fun AccountManualConfigContent(
-    onNextClick: () -> Unit,
-    onBackClick: () -> Unit,
-    modifier: Modifier = Modifier,
-) {
-    ResponsiveContentWithBackground(
-        modifier = modifier,
-    ) {
-        LazyColumnWithHeaderFooter(
-            modifier = Modifier.fillMaxSize(),
-            verticalArrangement = Arrangement.SpaceEvenly,
-            horizontalAlignment = Alignment.CenterHorizontally,
-            footer = {
-                AccountManualConfigFooter(
-                    onNextClick = onNextClick,
-                    onBackClick = onBackClick,
-                )
-            },
-        ) {
-            item {
-                TextHeadline5(text = "Manual Config")
-            }
-        }
-    }
-}
-
-@Composable
-private fun AccountManualConfigFooter(
-    onNextClick: () -> Unit,
-    onBackClick: () -> Unit,
-    modifier: Modifier = Modifier,
-) {
-    Row(
-        modifier = Modifier
-            .fillMaxWidth()
-            .padding(
-                start = MainTheme.spacings.quadruple,
-                top = MainTheme.spacings.triple,
-                end = MainTheme.spacings.quadruple,
-                bottom = MainTheme.spacings.double,
-            )
-            .then(modifier),
-        horizontalArrangement = Arrangement.SpaceBetween,
-    ) {
-        ButtonOutlined(
-            text = stringResource(id = R.string.account_setup_button_back),
-            onClick = onBackClick,
-        )
-        Button(
-            text = stringResource(id = R.string.account_setup_button_next),
-            onClick = onNextClick,
-        )
-    }
-}
-
-@Composable
-@DevicePreviews
-internal fun AccountManualConfigContentK9Preview() {
-    K9Theme {
-        AccountManualConfigContent(
-            onNextClick = { },
-            onBackClick = { },
-        )
-    }
-}
-
-@Composable
-@DevicePreviews
-internal fun AccountManualConfigContentThunderbirdPreview() {
-    ThunderbirdTheme {
-        AccountManualConfigContent(
-            onNextClick = { },
-            onBackClick = { },
-        )
-    }
-}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/manualconfig/AccountManualConfigScreen.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/manualconfig/AccountManualConfigScreen.kt
deleted file mode 100644
index 58d6c798144591a9303d5d1bc8d842cfedab2b68..0000000000000000000000000000000000000000
--- a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/manualconfig/AccountManualConfigScreen.kt
+++ /dev/null
@@ -1,14 +0,0 @@
-package app.k9mail.feature.account.setup.ui.manualconfig
-
-import androidx.compose.runtime.Composable
-
-@Composable
-fun AccountManualConfigScreen(
-    onNextClick: () -> Unit,
-    onBackClick: () -> Unit,
-) {
-    AccountManualConfigContent(
-        onNextClick = onNextClick,
-        onBackClick = onBackClick,
-    )
-}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsContent.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsContent.kt
index 04228c766e64289e410826951748f23003877c58..73ab106958ef4d875e196c0de351a8544d6af580 100644
--- a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsContent.kt
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsContent.kt
@@ -1,78 +1,149 @@
 package app.k9mail.feature.account.setup.ui.options
 
 import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.consumeWindowInsets
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.imePadding
 import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.requiredHeight
+import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.testTag
 import androidx.compose.ui.res.stringResource
 import app.k9mail.core.ui.compose.common.DevicePreviews
-import app.k9mail.core.ui.compose.designsystem.atom.button.Button
-import app.k9mail.core.ui.compose.designsystem.atom.button.ButtonOutlined
-import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline5
-import app.k9mail.core.ui.compose.designsystem.template.LazyColumnWithHeaderFooter
-import app.k9mail.core.ui.compose.designsystem.template.ResponsiveContentWithBackground
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextOverline
+import app.k9mail.core.ui.compose.designsystem.molecule.input.SelectInput
+import app.k9mail.core.ui.compose.designsystem.molecule.input.SwitchInput
+import app.k9mail.core.ui.compose.designsystem.molecule.input.TextInput
+import app.k9mail.core.ui.compose.designsystem.template.ResponsiveWidthContainer
 import app.k9mail.core.ui.compose.theme.K9Theme
 import app.k9mail.core.ui.compose.theme.MainTheme
 import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
+import app.k9mail.feature.account.common.ui.item.defaultHeadlineItemPadding
+import app.k9mail.feature.account.common.ui.item.defaultItemPadding
 import app.k9mail.feature.account.setup.R
+import app.k9mail.feature.account.setup.domain.entity.EmailCheckFrequency
+import app.k9mail.feature.account.setup.domain.entity.EmailDisplayCount
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.Event
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.State
 
+@OptIn(ExperimentalLayoutApi::class)
+@Suppress("LongMethod")
 @Composable
 internal fun AccountOptionsContent(
-    onFinishClick: () -> Unit,
-    onBackClick: () -> Unit,
+    state: State,
+    onEvent: (Event) -> Unit,
+    contentPadding: PaddingValues,
     modifier: Modifier = Modifier,
 ) {
-    ResponsiveContentWithBackground(
-        modifier = modifier,
+    val resources = LocalContext.current.resources
+
+    ResponsiveWidthContainer(
+        modifier = Modifier
+            .testTag("AccountOptionsContent")
+            .consumeWindowInsets(contentPadding)
+            .padding(contentPadding)
+            .then(modifier),
     ) {
-        LazyColumnWithHeaderFooter(
-            modifier = Modifier.fillMaxSize(),
-            verticalArrangement = Arrangement.SpaceEvenly,
-            horizontalAlignment = Alignment.CenterHorizontally,
-            footer = {
-                AccountOptionsFooter(
-                    onFinishClick = onFinishClick,
-                    onBackClick = onBackClick,
-                )
-            },
+        LazyColumn(
+            modifier = Modifier
+                .fillMaxSize()
+                .imePadding(),
+            horizontalAlignment = Alignment.Start,
+            verticalArrangement = Arrangement.spacedBy(MainTheme.spacings.default),
         ) {
             item {
-                TextHeadline5(text = "Options")
+                TextOverline(
+                    text = stringResource(id = R.string.account_setup_options_section_display_options),
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(defaultHeadlineItemPadding()),
+                )
             }
-        }
-    }
-}
 
-@Composable
-private fun AccountOptionsFooter(
-    onFinishClick: () -> Unit,
-    onBackClick: () -> Unit,
-    modifier: Modifier = Modifier,
-) {
-    Row(
-        modifier = Modifier
-            .fillMaxWidth()
-            .padding(
-                start = MainTheme.spacings.quadruple,
-                top = MainTheme.spacings.triple,
-                end = MainTheme.spacings.quadruple,
-                bottom = MainTheme.spacings.double,
-            )
-            .then(modifier),
-        horizontalArrangement = Arrangement.SpaceBetween,
-    ) {
-        ButtonOutlined(
-            text = stringResource(id = R.string.account_setup_button_back),
-            onClick = onBackClick,
-        )
-        Button(
-            text = stringResource(id = R.string.account_setup_button_finish),
-            onClick = onFinishClick,
-        )
+            item {
+                TextInput(
+                    text = state.accountName.value,
+                    errorMessage = state.accountName.error?.toResourceString(resources),
+                    onTextChange = { onEvent(Event.OnAccountNameChanged(it)) },
+                    label = stringResource(id = R.string.account_setup_options_account_name_label),
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+
+            item {
+                TextInput(
+                    text = state.displayName.value,
+                    errorMessage = state.displayName.error?.toResourceString(resources),
+                    onTextChange = { onEvent(Event.OnDisplayNameChanged(it)) },
+                    label = stringResource(id = R.string.account_setup_options_display_name_label),
+                    contentPadding = defaultItemPadding(),
+                    isRequired = true,
+                )
+            }
+
+            item {
+                TextInput(
+                    text = state.emailSignature.value,
+                    errorMessage = state.emailSignature.error?.toResourceString(resources),
+                    onTextChange = { onEvent(Event.OnEmailSignatureChanged(it)) },
+                    label = stringResource(id = R.string.account_setup_options_email_signature_label),
+                    contentPadding = defaultItemPadding(),
+                    isSingleLine = false,
+                )
+            }
+
+            item {
+                TextOverline(
+                    text = stringResource(id = R.string.account_setup_options_section_sync_options_),
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(defaultHeadlineItemPadding()),
+                )
+            }
+
+            item {
+                SelectInput(
+                    options = EmailCheckFrequency.all(),
+                    optionToStringTransformation = { it.toResourceString(resources) },
+                    selectedOption = state.checkFrequency,
+                    onOptionChange = { onEvent(Event.OnCheckFrequencyChanged(it)) },
+                    label = stringResource(id = R.string.account_setup_options_account_check_frequency_label),
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+
+            item {
+                SelectInput(
+                    options = EmailDisplayCount.all(),
+                    optionToStringTransformation = { it.toResourceString(resources) },
+                    selectedOption = state.messageDisplayCount,
+                    onOptionChange = { onEvent(Event.OnMessageDisplayCountChanged(it)) },
+                    label = stringResource(id = R.string.account_setup_options_email_display_count_label),
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+
+            item {
+                SwitchInput(
+                    text = stringResource(id = R.string.account_setup_options_show_notifications_label),
+                    checked = state.showNotification,
+                    onCheckedChange = { onEvent(Event.OnShowNotificationChanged(it)) },
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+
+            item {
+                Spacer(modifier = Modifier.requiredHeight(MainTheme.sizes.smaller))
+            }
+        }
     }
 }
 
@@ -81,8 +152,9 @@ private fun AccountOptionsFooter(
 internal fun AccountOptionsContentK9Preview() {
     K9Theme {
         AccountOptionsContent(
-            onFinishClick = { },
-            onBackClick = { },
+            state = State(),
+            onEvent = {},
+            contentPadding = PaddingValues(),
         )
     }
 }
@@ -92,8 +164,9 @@ internal fun AccountOptionsContentK9Preview() {
 internal fun AccountOptionsContentThunderbirdPreview() {
     ThunderbirdTheme {
         AccountOptionsContent(
-            onFinishClick = { },
-            onBackClick = { },
+            state = State(),
+            onEvent = {},
+            contentPadding = PaddingValues(),
         )
     }
 }
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsContract.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsContract.kt
new file mode 100644
index 0000000000000000000000000000000000000000..4472a6ed53edf4ff92e738ad141bf9b98ad22657
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsContract.kt
@@ -0,0 +1,46 @@
+package app.k9mail.feature.account.setup.ui.options
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.core.ui.compose.common.mvi.UnidirectionalViewModel
+import app.k9mail.feature.account.setup.domain.entity.EmailCheckFrequency
+import app.k9mail.feature.account.setup.domain.entity.EmailDisplayCount
+import app.k9mail.feature.account.setup.domain.input.StringInputField
+
+interface AccountOptionsContract {
+
+    interface ViewModel : UnidirectionalViewModel<State, Event, Effect>
+
+    data class State(
+        val accountName: StringInputField = StringInputField(),
+        val displayName: StringInputField = StringInputField(),
+        val emailSignature: StringInputField = StringInputField(),
+        val checkFrequency: EmailCheckFrequency = EmailCheckFrequency.DEFAULT,
+        val messageDisplayCount: EmailDisplayCount = EmailDisplayCount.DEFAULT,
+        val showNotification: Boolean = false,
+    )
+
+    sealed interface Event {
+        data class OnAccountNameChanged(val accountName: String) : Event
+        data class OnDisplayNameChanged(val displayName: String) : Event
+        data class OnEmailSignatureChanged(val emailSignature: String) : Event
+        data class OnCheckFrequencyChanged(val checkFrequency: EmailCheckFrequency) : Event
+        data class OnMessageDisplayCountChanged(val messageDisplayCount: EmailDisplayCount) : Event
+        data class OnShowNotificationChanged(val showNotification: Boolean) : Event
+
+        object LoadAccountSetupState : Event
+
+        object OnNextClicked : Event
+        object OnBackClicked : Event
+    }
+
+    sealed interface Effect {
+        object NavigateNext : Effect
+        object NavigateBack : Effect
+    }
+
+    interface Validator {
+        fun validateAccountName(accountName: String): ValidationResult
+        fun validateDisplayName(displayName: String): ValidationResult
+        fun validateEmailSignature(emailSignature: String): ValidationResult
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsScreen.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsScreen.kt
index 7635554e3bbee136074b20bc5dbc29111aa05bd7..0af78ec6250332056a4b334e55bd667fe07429af 100644
--- a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsScreen.kt
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsScreen.kt
@@ -1,14 +1,95 @@
 package app.k9mail.feature.account.setup.ui.options
 
+import androidx.activity.compose.BackHandler
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import app.k9mail.core.ui.compose.common.DevicePreviews
+import app.k9mail.core.ui.compose.common.mvi.observe
+import app.k9mail.core.ui.compose.designsystem.template.Scaffold
+import app.k9mail.core.ui.compose.theme.K9Theme
+import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
+import app.k9mail.feature.account.common.ui.WizardNavigationBar
+import app.k9mail.feature.account.setup.R.string
+import app.k9mail.feature.account.setup.ui.common.AccountSetupTopAppBar
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.Effect
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.Event
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.ViewModel
+import app.k9mail.feature.account.setup.ui.preview.PreviewAccountSetupStateRepository
 
 @Composable
-fun AccountOptionsScreen(
-    onFinishClick: () -> Unit,
-    onBackClick: () -> Unit,
+internal fun AccountOptionsScreen(
+    onNext: () -> Unit,
+    onBack: () -> Unit,
+    viewModel: ViewModel,
+    modifier: Modifier = Modifier,
 ) {
-    AccountOptionsContent(
-        onFinishClick = onFinishClick,
-        onBackClick = onBackClick,
-    )
+    val (state, dispatch) = viewModel.observe { effect ->
+        when (effect) {
+            Effect.NavigateBack -> onBack()
+            Effect.NavigateNext -> onNext()
+        }
+    }
+
+    LaunchedEffect(key1 = Unit) {
+        dispatch(Event.LoadAccountSetupState)
+    }
+
+    BackHandler {
+        dispatch(Event.OnBackClicked)
+    }
+
+    Scaffold(
+        topBar = {
+            AccountSetupTopAppBar(
+                title = stringResource(id = string.account_setup_options_top_bar_title),
+            )
+        },
+        bottomBar = {
+            WizardNavigationBar(
+                nextButtonText = stringResource(id = string.account_setup_button_finish),
+                backButtonText = stringResource(id = string.account_setup_button_back),
+                onNextClick = { dispatch(Event.OnNextClicked) },
+                onBackClick = { dispatch(Event.OnBackClicked) },
+            )
+        },
+        modifier = modifier,
+    ) { innerPadding ->
+        AccountOptionsContent(
+            state = state.value,
+            onEvent = { dispatch(it) },
+            contentPadding = innerPadding,
+        )
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountOptionsScreenK9Preview() {
+    K9Theme {
+        AccountOptionsScreen(
+            onNext = {},
+            onBack = {},
+            viewModel = AccountOptionsViewModel(
+                validator = AccountOptionsValidator(),
+                accountSetupStateRepository = PreviewAccountSetupStateRepository(),
+            ),
+        )
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountOptionsScreenThunderbirdPreview() {
+    ThunderbirdTheme {
+        AccountOptionsScreen(
+            onNext = {},
+            onBack = {},
+            viewModel = AccountOptionsViewModel(
+                validator = AccountOptionsValidator(),
+                accountSetupStateRepository = PreviewAccountSetupStateRepository(),
+            ),
+        )
+    }
 }
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsStateMapper.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsStateMapper.kt
new file mode 100644
index 0000000000000000000000000000000000000000..58d0c88b203e73f85ff58919c83ffca6cab855ee
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsStateMapper.kt
@@ -0,0 +1,37 @@
+package app.k9mail.feature.account.setup.ui.options
+
+import app.k9mail.feature.account.setup.domain.entity.AccountOptions
+import app.k9mail.feature.account.setup.domain.entity.AccountSetupState
+import app.k9mail.feature.account.setup.domain.entity.EmailCheckFrequency
+import app.k9mail.feature.account.setup.domain.entity.EmailDisplayCount
+import app.k9mail.feature.account.setup.domain.input.StringInputField
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.State
+
+internal fun AccountSetupState.toAccountOptionsState(): State {
+    val options = options
+    return if (options == null) {
+        State(
+            accountName = StringInputField(emailAddress ?: ""),
+        )
+    } else {
+        State(
+            accountName = StringInputField(options.accountName),
+            displayName = StringInputField(options.displayName),
+            emailSignature = StringInputField(options.emailSignature ?: ""),
+            checkFrequency = EmailCheckFrequency.fromMinutes(options.checkFrequencyInMinutes),
+            messageDisplayCount = EmailDisplayCount.fromCount(options.messageDisplayCount),
+            showNotification = options.showNotification,
+        )
+    }
+}
+
+internal fun State.toAccountOptions(): AccountOptions {
+    return AccountOptions(
+        accountName = accountName.value,
+        displayName = displayName.value,
+        emailSignature = emailSignature.value.takeIf { it.isNotEmpty() },
+        checkFrequencyInMinutes = checkFrequency.minutes,
+        messageDisplayCount = messageDisplayCount.count,
+        showNotification = showNotification,
+    )
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsStringMapper.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsStringMapper.kt
new file mode 100644
index 0000000000000000000000000000000000000000..eae82030ce269d979c88155b85753aab9b3c1ab6
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsStringMapper.kt
@@ -0,0 +1,65 @@
+package app.k9mail.feature.account.setup.ui.options
+
+import android.content.res.Resources
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.feature.account.setup.R
+import app.k9mail.feature.account.setup.domain.entity.EmailCheckFrequency
+import app.k9mail.feature.account.setup.domain.entity.EmailDisplayCount
+import app.k9mail.feature.account.setup.domain.usecase.ValidateAccountName.ValidateAccountNameError
+import app.k9mail.feature.account.setup.domain.usecase.ValidateAccountName.ValidateAccountNameError.BlankAccountName
+import app.k9mail.feature.account.setup.domain.usecase.ValidateDisplayName.ValidateDisplayNameError
+import app.k9mail.feature.account.setup.domain.usecase.ValidateDisplayName.ValidateDisplayNameError.EmptyDisplayName
+import app.k9mail.feature.account.setup.domain.usecase.ValidateEmailSignature.ValidateEmailSignatureError
+import app.k9mail.feature.account.setup.domain.usecase.ValidateEmailSignature.ValidateEmailSignatureError.BlankEmailSignature
+
+internal fun EmailDisplayCount.toResourceString(resources: Resources) = resources.getQuantityString(
+    R.plurals.account_setup_options_email_display_count_messages,
+    count,
+    count,
+)
+
+@Suppress("MagicNumber")
+internal fun EmailCheckFrequency.toResourceString(resources: Resources): String {
+    return when (minutes) {
+        -1 -> resources.getString(R.string.account_setup_options_email_check_frequency_never)
+
+        in 1..59 -> resources.getQuantityString(
+            R.plurals.account_setup_options_email_check_frequency_minutes,
+            minutes,
+            minutes,
+        )
+
+        else -> resources.getQuantityString(
+            R.plurals.account_setup_options_email_check_frequency_hours,
+            (minutes / 60),
+            (minutes / 60),
+        )
+    }
+}
+
+internal fun ValidationError.toResourceString(resources: Resources): String {
+    return when (this) {
+        is ValidateAccountNameError -> toAccountNameErrorString(resources)
+        is ValidateDisplayNameError -> toDisplayNameErrorString(resources)
+        is ValidateEmailSignatureError -> toEmailSignatureErrorString(resources)
+        else -> throw IllegalArgumentException("Unknown error: $this")
+    }
+}
+
+private fun ValidateAccountNameError.toAccountNameErrorString(resources: Resources): String {
+    return when (this) {
+        is BlankAccountName -> resources.getString(R.string.account_setup_options_account_name_error_blank)
+    }
+}
+
+private fun ValidateDisplayNameError.toDisplayNameErrorString(resources: Resources): String {
+    return when (this) {
+        is EmptyDisplayName -> resources.getString(R.string.account_setup_options_display_name_error_required)
+    }
+}
+
+private fun ValidateEmailSignatureError.toEmailSignatureErrorString(resources: Resources): String {
+    return when (this) {
+        is BlankEmailSignature -> resources.getString(R.string.account_setup_options_email_signature_error_blank)
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsValidator.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsValidator.kt
new file mode 100644
index 0000000000000000000000000000000000000000..4a167b311d55bfbd5a45ae7d623d11642259d289
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsValidator.kt
@@ -0,0 +1,25 @@
+package app.k9mail.feature.account.setup.ui.options
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.usecase.ValidateAccountName
+import app.k9mail.feature.account.setup.domain.usecase.ValidateDisplayName
+import app.k9mail.feature.account.setup.domain.usecase.ValidateEmailSignature
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.Validator
+
+internal class AccountOptionsValidator(
+    private val accountNameValidator: ValidateAccountName = ValidateAccountName(),
+    private val displayNameValidator: ValidateDisplayName = ValidateDisplayName(),
+    private val emailSignatureValidator: ValidateEmailSignature = ValidateEmailSignature(),
+) : Validator {
+    override fun validateAccountName(accountName: String): ValidationResult {
+        return accountNameValidator.execute(accountName)
+    }
+
+    override fun validateDisplayName(displayName: String): ValidationResult {
+        return displayNameValidator.execute(displayName)
+    }
+
+    override fun validateEmailSignature(emailSignature: String): ValidationResult {
+        return emailSignatureValidator.execute(emailSignature)
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsViewModel.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsViewModel.kt
new file mode 100644
index 0000000000000000000000000000000000000000..02e2901c54e5a9d93bfdfb1ef2acecadaca7a703
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsViewModel.kt
@@ -0,0 +1,100 @@
+package app.k9mail.feature.account.setup.ui.options
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.core.ui.compose.common.mvi.BaseViewModel
+import app.k9mail.feature.account.setup.domain.DomainContract
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.Effect
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.Event
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.State
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.Validator
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.ViewModel
+
+internal class AccountOptionsViewModel(
+    private val validator: Validator,
+    private val accountSetupStateRepository: DomainContract.AccountSetupStateRepository,
+    initialState: State? = null,
+) : BaseViewModel<State, Event, Effect>(
+    initialState = initialState ?: accountSetupStateRepository.getState().toAccountOptionsState(),
+),
+    ViewModel {
+
+    override fun event(event: Event) {
+        when (event) {
+            Event.LoadAccountSetupState -> loadAccountSetupState()
+
+            is Event.OnAccountNameChanged -> updateState { state ->
+                state.copy(
+                    accountName = state.accountName.updateValue(event.accountName),
+                )
+            }
+
+            is Event.OnDisplayNameChanged -> updateState {
+                it.copy(
+                    displayName = it.displayName.updateValue(event.displayName),
+                )
+            }
+
+            is Event.OnEmailSignatureChanged -> updateState {
+                it.copy(
+                    emailSignature = it.emailSignature.updateValue(event.emailSignature),
+                )
+            }
+
+            is Event.OnCheckFrequencyChanged -> updateState {
+                it.copy(
+                    checkFrequency = event.checkFrequency,
+                )
+            }
+
+            is Event.OnMessageDisplayCountChanged -> updateState { state ->
+                state.copy(
+                    messageDisplayCount = event.messageDisplayCount,
+                )
+            }
+
+            is Event.OnShowNotificationChanged -> updateState { state ->
+                state.copy(
+                    showNotification = event.showNotification,
+                )
+            }
+
+            Event.OnNextClicked -> submit()
+            Event.OnBackClicked -> navigateBack()
+        }
+    }
+
+    private fun loadAccountSetupState() {
+        updateState {
+            accountSetupStateRepository.getState().toAccountOptionsState()
+        }
+    }
+
+    private fun submit() = with(state.value) {
+        val accountNameResult = validator.validateAccountName(accountName.value)
+        val displayNameResult = validator.validateDisplayName(displayName.value)
+        val emailSignatureResult = validator.validateEmailSignature(emailSignature.value)
+
+        val hasError = listOf(
+            accountNameResult,
+            displayNameResult,
+            emailSignatureResult,
+        ).any { it is ValidationResult.Failure }
+
+        updateState {
+            it.copy(
+                accountName = it.accountName.updateFromValidationResult(accountNameResult),
+                displayName = it.displayName.updateFromValidationResult(displayNameResult),
+                emailSignature = it.emailSignature.updateFromValidationResult(emailSignatureResult),
+            )
+        }
+
+        if (!hasError) {
+            accountSetupStateRepository.saveOptions(state.value.toAccountOptions())
+            navigateNext()
+        }
+    }
+
+    private fun navigateBack() = emitEffect(Effect.NavigateBack)
+
+    private fun navigateNext() = emitEffect(Effect.NavigateNext)
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigContent.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigContent.kt
new file mode 100644
index 0000000000000000000000000000000000000000..ea9bd3bcbcbbf78959c701dd7470e097098d12fd
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigContent.kt
@@ -0,0 +1,168 @@
+package app.k9mail.feature.account.setup.ui.outgoing
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.imePadding
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.requiredHeight
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.stringResource
+import app.k9mail.core.ui.compose.common.DevicePreviews
+import app.k9mail.core.ui.compose.designsystem.molecule.input.NumberInput
+import app.k9mail.core.ui.compose.designsystem.molecule.input.PasswordInput
+import app.k9mail.core.ui.compose.designsystem.molecule.input.SelectInput
+import app.k9mail.core.ui.compose.designsystem.molecule.input.TextInput
+import app.k9mail.core.ui.compose.designsystem.template.ResponsiveWidthContainer
+import app.k9mail.core.ui.compose.theme.K9Theme
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
+import app.k9mail.feature.account.common.ui.item.defaultItemPadding
+import app.k9mail.feature.account.setup.R
+import app.k9mail.feature.account.setup.domain.entity.AuthenticationType
+import app.k9mail.feature.account.setup.domain.entity.ConnectionSecurity
+import app.k9mail.feature.account.setup.ui.clientcertificate.ClientCertificateInput
+import app.k9mail.feature.account.setup.ui.common.mapper.toResourceString
+import app.k9mail.feature.account.setup.ui.common.toResourceString
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.Event
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.State
+
+@Suppress("LongMethod")
+@Composable
+internal fun AccountOutgoingConfigContent(
+    state: State,
+    onEvent: (Event) -> Unit,
+    contentPadding: PaddingValues,
+    modifier: Modifier = Modifier,
+) {
+    val resources = LocalContext.current.resources
+
+    ResponsiveWidthContainer(
+        modifier = Modifier
+            .testTag("AccountOutgoingConfigContent")
+            .padding(contentPadding)
+            .fillMaxWidth()
+            .then(modifier),
+    ) {
+        LazyColumn(
+            modifier = Modifier
+                .fillMaxSize()
+                .imePadding(),
+            horizontalAlignment = Alignment.Start,
+            verticalArrangement = Arrangement.spacedBy(MainTheme.spacings.default),
+        ) {
+            item {
+                Spacer(modifier = Modifier.requiredHeight(MainTheme.sizes.smaller))
+            }
+
+            item {
+                TextInput(
+                    text = state.server.value,
+                    errorMessage = state.server.error?.toResourceString(resources),
+                    onTextChange = { onEvent(Event.ServerChanged(it)) },
+                    label = stringResource(id = R.string.account_setup_outgoing_config_server_label),
+                    isRequired = true,
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+
+            item {
+                SelectInput(
+                    options = ConnectionSecurity.all(),
+                    optionToStringTransformation = { it.toResourceString(resources) },
+                    selectedOption = state.security,
+                    onOptionChange = { onEvent(Event.SecurityChanged(it)) },
+                    label = stringResource(id = R.string.account_setup_outgoing_config_security_label),
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+
+            item {
+                NumberInput(
+                    value = state.port.value,
+                    errorMessage = state.port.error?.toResourceString(resources),
+                    onValueChange = { onEvent(Event.PortChanged(it)) },
+                    label = stringResource(id = R.string.account_setup_outgoing_config_port_label),
+                    isRequired = true,
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+
+            item {
+                SelectInput(
+                    options = AuthenticationType.outgoing(),
+                    optionToStringTransformation = { it.toResourceString(resources) },
+                    selectedOption = state.authenticationType,
+                    onOptionChange = { onEvent(Event.AuthenticationTypeChanged(it)) },
+                    label = stringResource(id = R.string.account_setup_outgoing_config_authentication_label),
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+
+            if (state.isUsernameFieldVisible) {
+                item {
+                    TextInput(
+                        text = state.username.value,
+                        errorMessage = state.username.error?.toResourceString(resources),
+                        onTextChange = { onEvent(Event.UsernameChanged(it)) },
+                        label = stringResource(id = R.string.account_setup_outgoing_config_username_label),
+                        isRequired = true,
+                        contentPadding = defaultItemPadding(),
+                    )
+                }
+            }
+
+            if (state.isPasswordFieldVisible) {
+                item {
+                    PasswordInput(
+                        password = state.password.value,
+                        errorMessage = state.password.error?.toResourceString(resources),
+                        onPasswordChange = { onEvent(Event.PasswordChanged(it)) },
+                        isRequired = true,
+                        contentPadding = defaultItemPadding(),
+                    )
+                }
+            }
+
+            item {
+                ClientCertificateInput(
+                    alias = state.clientCertificateAlias,
+                    onValueChange = { onEvent(Event.ClientCertificateChanged(it)) },
+                    label = stringResource(id = R.string.account_setup_client_certificate_label),
+                    contentPadding = defaultItemPadding(),
+                )
+            }
+        }
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountOutgoingConfigContentK9Preview() {
+    K9Theme {
+        AccountOutgoingConfigContent(
+            onEvent = { },
+            state = State(),
+            contentPadding = PaddingValues(),
+        )
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountOutgoingConfigContentThunderbirdPreview() {
+    ThunderbirdTheme {
+        AccountOutgoingConfigContent(
+            onEvent = { },
+            state = State(),
+            contentPadding = PaddingValues(),
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigContract.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigContract.kt
new file mode 100644
index 0000000000000000000000000000000000000000..daf9e3e4fa1aed145fd184b5d1bc34a0b3b414ba
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigContract.kt
@@ -0,0 +1,51 @@
+package app.k9mail.feature.account.setup.ui.outgoing
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.core.ui.compose.common.mvi.UnidirectionalViewModel
+import app.k9mail.feature.account.setup.domain.entity.AuthenticationType
+import app.k9mail.feature.account.setup.domain.entity.ConnectionSecurity
+import app.k9mail.feature.account.setup.domain.entity.toSmtpDefaultPort
+import app.k9mail.feature.account.setup.domain.input.NumberInputField
+import app.k9mail.feature.account.setup.domain.input.StringInputField
+
+interface AccountOutgoingConfigContract {
+
+    interface ViewModel : UnidirectionalViewModel<State, Event, Effect>
+
+    data class State(
+        val server: StringInputField = StringInputField(),
+        val security: ConnectionSecurity = ConnectionSecurity.DEFAULT,
+        val port: NumberInputField = NumberInputField(ConnectionSecurity.DEFAULT.toSmtpDefaultPort()),
+        val authenticationType: AuthenticationType = AuthenticationType.PasswordCleartext,
+        val username: StringInputField = StringInputField(),
+        val password: StringInputField = StringInputField(),
+        val clientCertificateAlias: String? = null,
+    )
+
+    sealed interface Event {
+        data class ServerChanged(val server: String) : Event
+        data class SecurityChanged(val security: ConnectionSecurity) : Event
+        data class PortChanged(val port: Long?) : Event
+        data class AuthenticationTypeChanged(val authenticationType: AuthenticationType) : Event
+        data class UsernameChanged(val username: String) : Event
+        data class PasswordChanged(val password: String) : Event
+        data class ClientCertificateChanged(val clientCertificateAlias: String?) : Event
+
+        object LoadAccountSetupState : Event
+
+        object OnNextClicked : Event
+        object OnBackClicked : Event
+    }
+
+    sealed interface Effect {
+        object NavigateNext : Effect
+        object NavigateBack : Effect
+    }
+
+    interface Validator {
+        fun validateServer(server: String): ValidationResult
+        fun validatePort(port: Long?): ValidationResult
+        fun validateUsername(username: String): ValidationResult
+        fun validatePassword(password: String): ValidationResult
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigScreen.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigScreen.kt
new file mode 100644
index 0000000000000000000000000000000000000000..e491c9916af60efe3c739c8e3b406bde1ca1c67f
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigScreen.kt
@@ -0,0 +1,95 @@
+package app.k9mail.feature.account.setup.ui.outgoing
+
+import androidx.activity.compose.BackHandler
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import app.k9mail.core.ui.compose.common.DevicePreviews
+import app.k9mail.core.ui.compose.common.mvi.observe
+import app.k9mail.core.ui.compose.designsystem.template.Scaffold
+import app.k9mail.core.ui.compose.theme.K9Theme
+import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
+import app.k9mail.feature.account.common.ui.WizardNavigationBar
+import app.k9mail.feature.account.setup.R
+import app.k9mail.feature.account.setup.ui.common.AccountSetupTopAppBar
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.Effect
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.Event
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.ViewModel
+import app.k9mail.feature.account.setup.ui.preview.PreviewAccountSetupStateRepository
+
+@Composable
+internal fun AccountOutgoingConfigScreen(
+    onNext: () -> Unit,
+    onBack: () -> Unit,
+    viewModel: ViewModel,
+    modifier: Modifier = Modifier,
+) {
+    val (state, dispatch) = viewModel.observe { effect ->
+        when (effect) {
+            Effect.NavigateBack -> onBack()
+            Effect.NavigateNext -> onNext()
+        }
+    }
+
+    LaunchedEffect(key1 = Unit) {
+        dispatch(Event.LoadAccountSetupState)
+    }
+
+    BackHandler {
+        dispatch(Event.OnBackClicked)
+    }
+
+    Scaffold(
+        topBar = {
+            AccountSetupTopAppBar(
+                title = stringResource(id = R.string.account_setup_outgoing_config_top_bar_title),
+            )
+        },
+        bottomBar = {
+            WizardNavigationBar(
+                nextButtonText = stringResource(id = R.string.account_setup_button_next),
+                backButtonText = stringResource(id = R.string.account_setup_button_back),
+                onNextClick = { dispatch(Event.OnNextClicked) },
+                onBackClick = { dispatch(Event.OnBackClicked) },
+            )
+        },
+        modifier = modifier,
+    ) { innerPadding ->
+        AccountOutgoingConfigContent(
+            state = state.value,
+            onEvent = { dispatch(it) },
+            contentPadding = innerPadding,
+        )
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountOutgoingConfigScreenK9Preview() {
+    K9Theme {
+        AccountOutgoingConfigScreen(
+            onNext = {},
+            onBack = {},
+            viewModel = AccountOutgoingConfigViewModel(
+                validator = AccountOutgoingConfigValidator(),
+                accountSetupStateRepository = PreviewAccountSetupStateRepository(),
+            ),
+        )
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountOutgoingConfigScreenThunderbirdPreview() {
+    ThunderbirdTheme {
+        AccountOutgoingConfigScreen(
+            onNext = {},
+            onBack = {},
+            viewModel = AccountOutgoingConfigViewModel(
+                validator = AccountOutgoingConfigValidator(),
+                accountSetupStateRepository = PreviewAccountSetupStateRepository(),
+            ),
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigStateExtensions.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigStateExtensions.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d80ffca57860c16a999c03683ead7443f1fad4c8
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigStateExtensions.kt
@@ -0,0 +1,7 @@
+package app.k9mail.feature.account.setup.ui.outgoing
+
+internal val AccountOutgoingConfigContract.State.isUsernameFieldVisible: Boolean
+    get() = authenticationType.isUsernameRequired
+
+internal val AccountOutgoingConfigContract.State.isPasswordFieldVisible: Boolean
+    get() = authenticationType.isPasswordRequired
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigStateMapper.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigStateMapper.kt
new file mode 100644
index 0000000000000000000000000000000000000000..ca636f95e2d9cbb2f3f242915e5c30083adb87c4
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigStateMapper.kt
@@ -0,0 +1,50 @@
+package app.k9mail.feature.account.setup.ui.outgoing
+
+import app.k9mail.feature.account.setup.domain.entity.AccountSetupState
+import app.k9mail.feature.account.setup.domain.entity.toAuthType
+import app.k9mail.feature.account.setup.domain.entity.toAuthenticationType
+import app.k9mail.feature.account.setup.domain.entity.toConnectionSecurity
+import app.k9mail.feature.account.setup.domain.entity.toMailConnectionSecurity
+import app.k9mail.feature.account.setup.domain.input.NumberInputField
+import app.k9mail.feature.account.setup.domain.input.StringInputField
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.State
+import app.k9mail.feature.account.setup.ui.validation.AccountValidationContract
+import com.fsck.k9.mail.ServerSettings
+
+internal fun AccountSetupState.toOutgoingConfigState(): State {
+    val outgoingServerSettings = outgoingServerSettings
+    return if (outgoingServerSettings == null) {
+        State(
+            username = StringInputField(value = emailAddress ?: ""),
+        )
+    } else {
+        State(
+            server = StringInputField(value = outgoingServerSettings.host ?: ""),
+            security = outgoingServerSettings.connectionSecurity.toConnectionSecurity(),
+            port = NumberInputField(value = outgoingServerSettings.port.toLong()),
+            authenticationType = outgoingServerSettings.authenticationType.toAuthenticationType(),
+            username = StringInputField(value = outgoingServerSettings.username),
+            password = StringInputField(value = outgoingServerSettings.password ?: ""),
+        )
+    }
+}
+
+internal fun State.toServerSettings(): ServerSettings {
+    return ServerSettings(
+        type = "smtp",
+        host = server.value,
+        port = port.value!!.toInt(),
+        connectionSecurity = security.toMailConnectionSecurity(),
+        authenticationType = authenticationType.toAuthType(),
+        username = if (authenticationType.isUsernameRequired) username.value else "",
+        password = if (authenticationType.isPasswordRequired) password.value else null,
+        clientCertificateAlias = clientCertificateAlias,
+    )
+}
+
+internal fun State.toValidationState(): AccountValidationContract.State {
+    return AccountValidationContract.State(
+        serverSettings = toServerSettings(),
+        // TODO add authorization state
+    )
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigValidator.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigValidator.kt
new file mode 100644
index 0000000000000000000000000000000000000000..a4c71d35e4af58d48b2f2019bf9c37788257eb24
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigValidator.kt
@@ -0,0 +1,30 @@
+package app.k9mail.feature.account.setup.ui.outgoing
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.usecase.ValidatePassword
+import app.k9mail.feature.account.setup.domain.usecase.ValidatePort
+import app.k9mail.feature.account.setup.domain.usecase.ValidateServer
+import app.k9mail.feature.account.setup.domain.usecase.ValidateUsername
+
+internal class AccountOutgoingConfigValidator(
+    private val serverValidator: ValidateServer = ValidateServer(),
+    private val portValidator: ValidatePort = ValidatePort(),
+    private val usernameValidator: ValidateUsername = ValidateUsername(),
+    private val passwordValidator: ValidatePassword = ValidatePassword(),
+) : AccountOutgoingConfigContract.Validator {
+    override fun validateServer(server: String): ValidationResult {
+        return serverValidator.execute(server)
+    }
+
+    override fun validatePort(port: Long?): ValidationResult {
+        return portValidator.execute(port)
+    }
+
+    override fun validateUsername(username: String): ValidationResult {
+        return usernameValidator.execute(username)
+    }
+
+    override fun validatePassword(password: String): ValidationResult {
+        return passwordValidator.execute(password)
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigViewModel.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigViewModel.kt
new file mode 100644
index 0000000000000000000000000000000000000000..73b761e1b8f14151edff81fd1c5edc8251b3c364
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigViewModel.kt
@@ -0,0 +1,96 @@
+package app.k9mail.feature.account.setup.ui.outgoing
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.core.ui.compose.common.mvi.BaseViewModel
+import app.k9mail.feature.account.setup.domain.DomainContract
+import app.k9mail.feature.account.setup.domain.entity.ConnectionSecurity
+import app.k9mail.feature.account.setup.domain.entity.toSmtpDefaultPort
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.Effect
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.Event
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.State
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.Validator
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.ViewModel
+
+internal class AccountOutgoingConfigViewModel(
+    private val validator: Validator,
+    private val accountSetupStateRepository: DomainContract.AccountSetupStateRepository,
+    initialState: State? = State(),
+) : BaseViewModel<State, Event, Effect>(
+    initialState = initialState ?: accountSetupStateRepository.getState().toOutgoingConfigState(),
+),
+    ViewModel {
+
+    override fun event(event: Event) {
+        when (event) {
+            Event.LoadAccountSetupState -> loadAccountSetupState()
+
+            is Event.ServerChanged -> updateState { it.copy(server = it.server.updateValue(event.server)) }
+            is Event.SecurityChanged -> updateSecurity(event.security)
+            is Event.PortChanged -> updateState { it.copy(port = it.port.updateValue(event.port)) }
+            is Event.AuthenticationTypeChanged -> updateState { it.copy(authenticationType = event.authenticationType) }
+            is Event.UsernameChanged -> updateState { it.copy(username = it.username.updateValue(event.username)) }
+            is Event.PasswordChanged -> updateState { it.copy(password = it.password.updateValue(event.password)) }
+            is Event.ClientCertificateChanged -> updateState {
+                it.copy(clientCertificateAlias = event.clientCertificateAlias)
+            }
+
+            Event.OnNextClicked -> onNext()
+            Event.OnBackClicked -> onBack()
+        }
+    }
+
+    private fun loadAccountSetupState() {
+        updateState {
+            accountSetupStateRepository.getState().toOutgoingConfigState()
+        }
+    }
+
+    private fun onNext() {
+        submitConfig()
+    }
+
+    private fun updateSecurity(security: ConnectionSecurity) {
+        updateState {
+            it.copy(
+                security = security,
+                port = it.port.updateValue(security.toSmtpDefaultPort()),
+            )
+        }
+    }
+
+    private fun submitConfig() = with(state.value) {
+        val serverResult = validator.validateServer(server.value)
+        val portResult = validator.validatePort(port.value)
+        val usernameResult = validator.validateUsername(username.value)
+        val passwordResult = if (authenticationType.isPasswordRequired) {
+            validator.validatePassword(password.value)
+        } else {
+            ValidationResult.Success
+        }
+
+        val hasError = listOf(serverResult, portResult, usernameResult, passwordResult)
+            .any { it is ValidationResult.Failure }
+
+        updateState {
+            it.copy(
+                server = it.server.updateFromValidationResult(serverResult),
+                port = it.port.updateFromValidationResult(portResult),
+                username = it.username.updateFromValidationResult(usernameResult),
+                password = it.password.updateFromValidationResult(passwordResult),
+            )
+        }
+
+        if (!hasError) {
+            accountSetupStateRepository.saveOutgoingServerSettings(state.value.toServerSettings())
+            navigateNext()
+        }
+    }
+
+    private fun onBack() {
+        navigateBack()
+    }
+
+    private fun navigateBack() = emitEffect(Effect.NavigateBack)
+
+    private fun navigateNext() = emitEffect(Effect.NavigateNext)
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/preview/PreviewAccountSetupStateRepository.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/preview/PreviewAccountSetupStateRepository.kt
new file mode 100644
index 0000000000000000000000000000000000000000..bc3aabb081c3e427ff41ea82c5fedde3d5a889d2
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/preview/PreviewAccountSetupStateRepository.kt
@@ -0,0 +1,49 @@
+package app.k9mail.feature.account.setup.ui.preview
+
+import app.k9mail.feature.account.oauth.domain.entity.AuthorizationState
+import app.k9mail.feature.account.setup.domain.DomainContract
+import app.k9mail.feature.account.setup.domain.entity.AccountOptions
+import app.k9mail.feature.account.setup.domain.entity.AccountSetupState
+import app.k9mail.feature.account.setup.domain.entity.MailConnectionSecurity
+import com.fsck.k9.mail.AuthType
+import com.fsck.k9.mail.ServerSettings
+
+class PreviewAccountSetupStateRepository : DomainContract.AccountSetupStateRepository {
+    override fun getState(): AccountSetupState = AccountSetupState(
+        emailAddress = "test@example.com",
+        incomingServerSettings = ServerSettings(
+            type = "imap",
+            host = "imap.example.com",
+            port = 993,
+            connectionSecurity = MailConnectionSecurity.SSL_TLS_REQUIRED,
+            authenticationType = AuthType.PLAIN,
+            username = "test",
+            password = "password",
+            clientCertificateAlias = null,
+        ),
+        outgoingServerSettings = ServerSettings(
+            type = "smtp",
+            host = "smtp.example.com",
+            port = 465,
+            connectionSecurity = MailConnectionSecurity.SSL_TLS_REQUIRED,
+            authenticationType = AuthType.PLAIN,
+            username = "test",
+            password = "password",
+            clientCertificateAlias = null,
+        ),
+    )
+
+    override fun save(accountSetupState: AccountSetupState) = Unit
+
+    override fun saveEmailAddress(emailAddress: String) = Unit
+
+    override fun saveIncomingServerSettings(serverSettings: ServerSettings) = Unit
+
+    override fun saveOutgoingServerSettings(serverSettings: ServerSettings) = Unit
+
+    override fun saveAuthorizationState(authorizationState: AuthorizationState) = Unit
+
+    override fun saveOptions(options: AccountOptions) = Unit
+
+    override fun clear() = Unit
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/servercertificate/CertificateErrorContract.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/servercertificate/CertificateErrorContract.kt
new file mode 100644
index 0000000000000000000000000000000000000000..18ffe42a7f662f33e0b6616a5fb2fba8e585c1d5
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/servercertificate/CertificateErrorContract.kt
@@ -0,0 +1,22 @@
+package app.k9mail.feature.account.setup.ui.servercertificate
+
+import app.k9mail.core.ui.compose.common.mvi.UnidirectionalViewModel
+
+interface CertificateErrorContract {
+
+    interface ViewModel : UnidirectionalViewModel<State, Event, Effect>
+
+    data class State(
+        val errorText: String = "",
+    )
+
+    sealed interface Event {
+        object OnCertificateAcceptedClicked : Event
+        object OnBackClicked : Event
+    }
+
+    sealed interface Effect {
+        object NavigateCertificateAccepted : Effect
+        object NavigateBack : Effect
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/servercertificate/CertificateErrorScreen.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/servercertificate/CertificateErrorScreen.kt
new file mode 100644
index 0000000000000000000000000000000000000000..f02b471a3b99434ab41948d82bb7713765012b0d
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/servercertificate/CertificateErrorScreen.kt
@@ -0,0 +1,157 @@
+package app.k9mail.feature.account.setup.ui.servercertificate
+
+import androidx.activity.compose.BackHandler
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import app.k9mail.core.ui.compose.common.DevicePreviews
+import app.k9mail.core.ui.compose.common.mvi.observe
+import app.k9mail.core.ui.compose.designsystem.atom.button.Button
+import app.k9mail.core.ui.compose.designsystem.atom.button.ButtonOutlined
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextBody1
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextHeadline4
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextSubtitle1
+import app.k9mail.core.ui.compose.designsystem.template.ResponsiveWidthContainer
+import app.k9mail.core.ui.compose.designsystem.template.Scaffold
+import app.k9mail.core.ui.compose.theme.K9Theme
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.feature.account.setup.data.InMemoryCertificateErrorRepository
+import app.k9mail.feature.account.setup.domain.entity.CertificateError
+import app.k9mail.feature.account.setup.ui.servercertificate.CertificateErrorContract.Effect
+import app.k9mail.feature.account.setup.ui.servercertificate.CertificateErrorContract.Event
+import app.k9mail.feature.account.setup.ui.servercertificate.CertificateErrorContract.ViewModel
+import java.security.cert.CertificateFactory
+import java.security.cert.X509Certificate
+import org.koin.androidx.compose.koinViewModel
+
+// Note: This is a placeholder with mostly hardcoded text.
+// TODO: Replace with final design.
+@Composable
+internal fun CertificateErrorScreen(
+    onCertificateAccepted: () -> Unit,
+    onBack: () -> Unit,
+    modifier: Modifier = Modifier,
+    viewModel: ViewModel = koinViewModel<CertificateErrorViewModel>(),
+) {
+    val (state, dispatch) = viewModel.observe { effect ->
+        when (effect) {
+            is Effect.NavigateCertificateAccepted -> onCertificateAccepted()
+            is Effect.NavigateBack -> onBack()
+        }
+    }
+
+    BackHandler {
+        dispatch(Event.OnBackClicked)
+    }
+
+    Scaffold(
+        bottomBar = {
+            ResponsiveWidthContainer(
+                modifier = Modifier
+                    .padding(start = MainTheme.spacings.double, end = MainTheme.spacings.double),
+            ) {
+                Column {
+                    Button(
+                        text = "Go back (recommended)",
+                        onClick = { dispatch(Event.OnBackClicked) },
+                        modifier = Modifier
+                            .fillMaxWidth(),
+                    )
+                    ButtonOutlined(
+                        text = "Accept consequences and continue",
+                        onClick = { dispatch(Event.OnCertificateAcceptedClicked) },
+                        modifier = Modifier.fillMaxWidth(),
+                    )
+                }
+            }
+        },
+        modifier = modifier,
+    ) { innerPadding ->
+        ResponsiveWidthContainer(modifier = Modifier.padding(innerPadding)) {
+            Column(
+                modifier = Modifier
+                    .verticalScroll(rememberScrollState())
+                    .padding(all = MainTheme.spacings.double),
+            ) {
+                TextHeadline4(text = "Warning")
+                TextSubtitle1("Invalid certificate")
+
+                Spacer(modifier = Modifier.height(MainTheme.spacings.quadruple))
+
+                TextBody1(
+                    text = "The server presented an invalid TLS certificate. " +
+                        "Sometimes, this is because of a server misconfiguration. " +
+                        "Sometimes it is because someone is trying to attack you or your mail server. " +
+                        "If you're not sure what's up, click \"Go back\" and contact the folks who manage your " +
+                        "mail server.",
+                )
+
+                Spacer(modifier = Modifier.height(MainTheme.spacings.quadruple))
+
+                TextBody1(state.value.errorText)
+            }
+        }
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun CertificateErrorScreenK9Preview() {
+    val inputStream = """
+        -----BEGIN CERTIFICATE-----
+        MIIE8jCCA9qgAwIBAgISA3bsPKY1eoe/RiBO2t8fUvh1MA0GCSqGSIb3DQEBCwUA
+        MDIxCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1MZXQncyBFbmNyeXB0MQswCQYDVQQD
+        EwJSMzAeFw0yMzA3MjEyMDU1MTJaFw0yMzEwMTkyMDU1MTFaMBcxFTATBgNVBAMM
+        DCouYmFkc3NsLmNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAJgw
+        o/dYmPaujmm7sqIuZCe5/kyMwDYKo/pWeeXSvQxRXhxiVvd2Xu9PG0ZXW2R0xOSr
+        BpaRWm6MXxEnNqNr+n22j9US6M62zJpcuU4tQ0J8xRyIGL6rM53z59rEnCdkF9HQ
+        +7y7PBlVXCm0jrw51h3Bg5qryvTFyimIbqGw0UJhM7m/NaVJWZyBRwHp7emXxRJC
+        kC7pdX462c+m/7rQ06iohqUt6mf0DkUH1QjpaVbZm8CBs/GSiLB3LdMHj1uvrXgH
+        z8dp0nQ3eVRCjuD1xVcZnFoeEa/W3a9ZdcBj1phr9XOwaqYMeAv64g2w40G6fXMH
+        9DpHuFarRtleQusiPAMCAwEAAaOCAhswggIXMA4GA1UdDwEB/wQEAwIFoDAdBgNV
+        HSUEFjAUBggrBgEFBQcDAQYIKwYBBQUHAwIwDAYDVR0TAQH/BAIwADAdBgNVHQ4E
+        FgQU1M4J2vX/9DWJnsAtofmT+94js/YwHwYDVR0jBBgwFoAUFC6zF7dYVsuuUAlA
+        5h+vnYsUwsYwVQYIKwYBBQUHAQEESTBHMCEGCCsGAQUFBzABhhVodHRwOi8vcjMu
+        by5sZW5jci5vcmcwIgYIKwYBBQUHMAKGFmh0dHA6Ly9yMy5pLmxlbmNyLm9yZy8w
+        IwYDVR0RBBwwGoIMKi5iYWRzc2wuY29tggpiYWRzc2wuY29tMBMGA1UdIAQMMAow
+        CAYGZ4EMAQIBMIIBBQYKKwYBBAHWeQIEAgSB9gSB8wDxAHYAtz77JN+cTbp18jnF
+        ulj0bF38Qs96nzXEnh0JgSXttJkAAAGJenMebAAABAMARzBFAiAH7A3OWC1AKOcO
+        jsOP39nzkyoIdrwYFHOOW1qKkLrk9gIhAJD0xFn5FwJvag3K6mTXAlW1EvIy9joA
+        okiPniKVBIztAHcAejKMVNi3LbYg6jjgUh7phBZwMhOFTTvSK8E6V6NS61IAAAGJ
+        enMehwAABAMASDBGAiEAvRyLnINSJQ0WyfcU8L0PY5z7//Gq8P9i2HJvZJvnfBkC
+        IQCHslQMJaOg+rn9+2WW4KKgYW/yDrvBbiVABW5CcYWR0DANBgkqhkiG9w0BAQsF
+        AAOCAQEAB/JpXHqRnGmCFz3f0hx7mJYY/auSNWnOgpdRpc3JXzcOHHUd+569UGtu
+        TSMAFEGNXYTbXrG52iGBCrdfe1kkRokg7/KtUvFRelkoNt4FN/4/zVjBxINXVIMb
+        /7toq4OxBF/sz4SU+eXanmwJyOMmNQzM94zqDwrEmMNuNLYshdWn7XyJCXIM4X+6
+        8M/anh/pi2AviLHH9pszkeuH3AjGJR68cPf+QKC4XcFloR08fhx0jKl8LBa4A6Nm
+        o7IlPgdD9rzZCsbYe+VNBQWY3358u7ifOJG8r2jXzyHKgUC+OBXgz3kjrClzJfl1
+        pjcJhNU1UQtIVERwmxI9F5oQqUyxvA==
+        -----END CERTIFICATE-----
+    """.trimIndent().byteInputStream()
+
+    val certificateFactory = CertificateFactory.getInstance("X.509")
+    val certificate = certificateFactory.generateCertificate(inputStream) as X509Certificate
+
+    val certificateError = CertificateError(
+        hostname = "mail.domain.example",
+        port = 143,
+        certificateChain = listOf(certificate),
+    )
+
+    K9Theme {
+        CertificateErrorScreen(
+            onCertificateAccepted = {},
+            onBack = {},
+            viewModel = CertificateErrorViewModel(
+                addServerCertificateException = { _, _, _ -> },
+                certificateErrorRepository = InMemoryCertificateErrorRepository(certificateError),
+            ),
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/servercertificate/CertificateErrorViewModel.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/servercertificate/CertificateErrorViewModel.kt
new file mode 100644
index 0000000000000000000000000000000000000000..1edcde33221397e0a63c91f0ea70fa048f57b1d7
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/servercertificate/CertificateErrorViewModel.kt
@@ -0,0 +1,105 @@
+package app.k9mail.feature.account.setup.ui.servercertificate
+
+import androidx.lifecycle.viewModelScope
+import app.k9mail.core.ui.compose.common.mvi.BaseViewModel
+import app.k9mail.feature.account.setup.domain.DomainContract.CertificateErrorRepository
+import app.k9mail.feature.account.setup.domain.DomainContract.UseCase.AddServerCertificateException
+import app.k9mail.feature.account.setup.domain.entity.CertificateError
+import app.k9mail.feature.account.setup.ui.servercertificate.CertificateErrorContract.Effect
+import app.k9mail.feature.account.setup.ui.servercertificate.CertificateErrorContract.Event
+import app.k9mail.feature.account.setup.ui.servercertificate.CertificateErrorContract.State
+import com.fsck.k9.logging.Timber
+import com.fsck.k9.mail.filter.Hex
+import java.security.MessageDigest
+import java.security.NoSuchAlgorithmException
+import java.security.cert.CertificateEncodingException
+import kotlinx.coroutines.launch
+
+class CertificateErrorViewModel(
+    private val certificateErrorRepository: CertificateErrorRepository,
+    private val addServerCertificateException: AddServerCertificateException,
+    initialState: State = State(),
+) : BaseViewModel<State, Event, Effect>(initialState), CertificateErrorContract.ViewModel {
+    private val certificateError: CertificateError? = certificateErrorRepository.getCertificateError()
+
+    init {
+        setErrorMessage(buildErrorMessage(certificateError))
+    }
+
+    override fun event(event: Event) {
+        when (event) {
+            Event.OnCertificateAcceptedClicked -> acceptCertificate()
+            Event.OnBackClicked -> navigateBack()
+        }
+    }
+
+    private fun acceptCertificate() {
+        val certificateError = requireNotNull(certificateError)
+
+        viewModelScope.launch {
+            addServerCertificateException.addCertificate(
+                hostname = certificateError.hostname,
+                port = certificateError.port,
+                certificate = certificateError.certificateChain.first(),
+            )
+
+            certificateErrorRepository.clearCertificateError()
+            navigateCertificateAccepted()
+        }
+    }
+
+    private fun navigateBack() {
+        emitEffect(Effect.NavigateBack)
+    }
+
+    private fun navigateCertificateAccepted() {
+        emitEffect(Effect.NavigateCertificateAccepted)
+    }
+
+    private fun buildErrorMessage(certificateError: CertificateError?): String {
+        val certificate = certificateError?.certificateChain?.firstOrNull() ?: return ""
+
+        return buildString {
+            certificate.subjectAlternativeNames?.let { subjectAlternativeNames ->
+                append("Subject alternative names:\n")
+                for (subjectAlternativeName in subjectAlternativeNames) {
+                    append("- ").append(subjectAlternativeName[1]).append("\n")
+                }
+            }
+            append("\n")
+
+            append("Not valid before: ").append(certificate.notBefore).append("\n")
+            append("Not valid after: ").append(certificate.notAfter).append("\n")
+            append("\n")
+
+            append("Subject: ").append(certificate.subjectDN).append("\n")
+            append("Issuer: ").append(certificate.issuerX500Principal).append("\n")
+            append("\n")
+
+            for (algorithm in arrayOf("SHA-1", "SHA-256", "SHA-512")) {
+                val digest = try {
+                    MessageDigest.getInstance(algorithm)
+                } catch (e: NoSuchAlgorithmException) {
+                    Timber.e(e, "Error while initializing MessageDigest (%s)", algorithm)
+                    null
+                }
+
+                if (digest != null) {
+                    digest.reset()
+                    try {
+                        val hash = Hex.encodeHex(digest.digest(certificate.encoded))
+                        append("Fingerprint (").append(algorithm).append("): \n").append(hash).append("\n")
+                    } catch (e: CertificateEncodingException) {
+                        Timber.e(e, "Error while encoding certificate")
+                    }
+                }
+            }
+        }
+    }
+
+    private fun setErrorMessage(errorText: String) {
+        updateState {
+            it.copy(errorText = errorText)
+        }
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/validation/AccountValidationContent.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/validation/AccountValidationContent.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c380abafc1b3723ecfed7a30e170be7d4b7c0766
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/validation/AccountValidationContent.kt
@@ -0,0 +1,151 @@
+package app.k9mail.feature.account.setup.ui.validation
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.imePadding
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.res.stringResource
+import app.k9mail.core.ui.compose.common.DevicePreviews
+import app.k9mail.core.ui.compose.designsystem.atom.text.TextSubtitle1
+import app.k9mail.core.ui.compose.designsystem.template.ResponsiveWidthContainer
+import app.k9mail.core.ui.compose.theme.MainTheme
+import app.k9mail.core.ui.compose.theme.PreviewWithThemes
+import app.k9mail.feature.account.common.ui.item.ErrorItem
+import app.k9mail.feature.account.common.ui.item.ListItem
+import app.k9mail.feature.account.common.ui.item.LoadingItem
+import app.k9mail.feature.account.common.ui.item.SuccessItem
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract
+import app.k9mail.feature.account.oauth.ui.AccountOAuthView
+import app.k9mail.feature.account.oauth.ui.preview.PreviewAccountOAuthViewModel
+import app.k9mail.feature.account.setup.R
+import app.k9mail.feature.account.setup.ui.validation.AccountValidationContract.Event
+import app.k9mail.feature.account.setup.ui.validation.AccountValidationContract.State
+
+@Suppress("LongMethod")
+@Composable
+internal fun AccountValidationContent(
+    state: State,
+    isIncomingValidation: Boolean,
+    oAuthViewModel: AccountOAuthContract.ViewModel,
+    onEvent: (Event) -> Unit,
+    contentPadding: PaddingValues,
+    modifier: Modifier = Modifier,
+) {
+    val resources = LocalContext.current.resources
+
+    ResponsiveWidthContainer(
+        modifier = Modifier
+            .testTag("AccountValidationContent")
+            .padding(contentPadding)
+            .fillMaxWidth()
+            .then(modifier),
+    ) {
+        LazyColumn(
+            modifier = Modifier
+                .fillMaxSize()
+                .imePadding(),
+            horizontalAlignment = Alignment.Start,
+            verticalArrangement = Arrangement.spacedBy(MainTheme.spacings.double, Alignment.CenterVertically),
+        ) {
+            if (state.error != null) {
+                item(key = "error") {
+                    // TODO add raw error message
+                    ErrorItem(
+                        title = stringResource(
+                            id = if (isIncomingValidation) {
+                                R.string.account_setup_settings_validation_incoming_loading_error
+                            } else {
+                                R.string.account_setup_settings_validation_outgoing_loading_error
+                            },
+                        ),
+                        message = state.error.toResourceString(resources),
+                        onRetry = { onEvent(Event.OnRetryClicked) },
+                    )
+                }
+            } else if (state.isSuccess) {
+                item(key = "success") {
+                    SuccessItem(
+                        message = stringResource(
+                            id = if (isIncomingValidation) {
+                                R.string.account_setup_settings_validation_incoming_success
+                            } else {
+                                R.string.account_setup_settings_validation_outgoing_success
+                            },
+                        ),
+                    )
+                }
+            } else if (state.needsAuthorization) {
+                item(key = "oauth") {
+                    ListItem {
+                        Column(
+                            modifier = Modifier
+                                .fillMaxWidth(),
+                            horizontalAlignment = Alignment.CenterHorizontally,
+                        ) {
+                            TextSubtitle1(
+                                text = stringResource(
+                                    id = R.string.account_setup_settings_validation_sign_in,
+                                ),
+                            )
+                            Spacer(modifier = Modifier.padding(MainTheme.spacings.default))
+                            AccountOAuthView(
+                                onOAuthResult = { result -> onEvent(Event.OnOAuthResult(result)) },
+                                viewModel = oAuthViewModel,
+                            )
+                        }
+                    }
+                }
+            } else {
+                item(key = "loading") {
+                    LoadingItem(
+                        message = stringResource(
+                            id = if (isIncomingValidation) {
+                                R.string.account_setup_settings_validation_incoming_loading_message
+                            } else {
+                                R.string.account_setup_settings_validation_outgoing_loading_message
+                            },
+                        ),
+                    )
+                }
+            }
+        }
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountIncomingValidationContentPreview() {
+    PreviewWithThemes {
+        AccountValidationContent(
+            onEvent = { },
+            state = State(),
+            isIncomingValidation = true,
+            oAuthViewModel = PreviewAccountOAuthViewModel(),
+            contentPadding = PaddingValues(),
+        )
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountOutgoingValidationContentPreview() {
+    PreviewWithThemes {
+        AccountValidationContent(
+            onEvent = { },
+            state = State(),
+            isIncomingValidation = false,
+            oAuthViewModel = PreviewAccountOAuthViewModel(),
+            contentPadding = PaddingValues(),
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/validation/AccountValidationContract.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/validation/AccountValidationContract.kt
new file mode 100644
index 0000000000000000000000000000000000000000..a7edfee0dc05d7a1d29d97256f12c56a175e6c2c
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/validation/AccountValidationContract.kt
@@ -0,0 +1,50 @@
+package app.k9mail.feature.account.setup.ui.validation
+
+import app.k9mail.core.ui.compose.common.mvi.UnidirectionalViewModel
+import app.k9mail.feature.account.oauth.domain.entity.OAuthResult
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract
+import com.fsck.k9.mail.ServerSettings
+import java.io.IOException
+import java.security.cert.X509Certificate
+
+interface AccountValidationContract {
+
+    interface ViewModel : UnidirectionalViewModel<State, Event, Effect> {
+        val isIncomingValidation: Boolean
+        val oAuthViewModel: AccountOAuthContract.ViewModel
+    }
+
+    data class State(
+        val emailAddress: String? = null,
+        val serverSettings: ServerSettings? = null,
+        val needsAuthorization: Boolean = false,
+        val isSuccess: Boolean = false,
+        val error: Error? = null,
+        val isLoading: Boolean = false,
+    )
+
+    sealed interface Event {
+        object LoadAccountSetupStateAndValidate : Event
+
+        data class OnOAuthResult(val result: OAuthResult) : Event
+
+        object ValidateServerSettings : Event
+        object OnNextClicked : Event
+        object OnBackClicked : Event
+        object OnRetryClicked : Event
+        object OnCertificateAccepted : Event
+    }
+
+    sealed interface Effect {
+        object NavigateNext : Effect
+        object NavigateBack : Effect
+    }
+
+    sealed interface Error {
+        data class NetworkError(val exception: IOException) : Error
+        data class CertificateError(val certificateChain: List<X509Certificate>) : Error
+        data class AuthenticationError(val serverMessage: String?) : Error
+        data class ServerError(val serverMessage: String?) : Error
+        data class UnknownError(val message: String) : Error
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/validation/AccountValidationMainScreen.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/validation/AccountValidationMainScreen.kt
new file mode 100644
index 0000000000000000000000000000000000000000..16709f10b4bea397aac86c5cd524558cefcb3fac
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/validation/AccountValidationMainScreen.kt
@@ -0,0 +1,131 @@
+package app.k9mail.feature.account.setup.ui.validation
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import app.k9mail.core.ui.compose.common.DevicePreviews
+import app.k9mail.core.ui.compose.designsystem.template.Scaffold
+import app.k9mail.core.ui.compose.theme.K9Theme
+import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
+import app.k9mail.feature.account.common.ui.AppTitleTopHeader
+import app.k9mail.feature.account.common.ui.WizardNavigationBar
+import app.k9mail.feature.account.common.ui.WizardNavigationBarState
+import app.k9mail.feature.account.oauth.ui.preview.PreviewAccountOAuthViewModel
+import app.k9mail.feature.account.setup.R
+import app.k9mail.feature.account.setup.data.InMemoryCertificateErrorRepository
+import app.k9mail.feature.account.setup.ui.preview.PreviewAccountSetupStateRepository
+import app.k9mail.feature.account.setup.ui.validation.AccountValidationContract.Event
+import app.k9mail.feature.account.setup.ui.validation.AccountValidationContract.ViewModel
+import com.fsck.k9.mail.server.ServerSettingsValidationResult
+
+@Composable
+internal fun AccountValidationMainScreen(
+    viewModel: ViewModel,
+    modifier: Modifier = Modifier,
+) {
+    val state = viewModel.state.collectAsStateWithLifecycle()
+    val dispatch = { event: Event -> viewModel.event(event) }
+
+    Scaffold(
+        topBar = {
+            AppTitleTopHeader(title = stringResource(id = R.string.account_setup_title))
+        },
+        bottomBar = {
+            WizardNavigationBar(
+                nextButtonText = "",
+                backButtonText = stringResource(id = R.string.account_setup_button_back),
+                onNextClick = {},
+                onBackClick = { dispatch(Event.OnBackClicked) },
+                state = WizardNavigationBarState(
+                    showNext = false,
+                ),
+            )
+        },
+        modifier = modifier,
+    ) { innerPadding ->
+        AccountValidationContent(
+            onEvent = { dispatch(it) },
+            state = state.value,
+            isIncomingValidation = viewModel.isIncomingValidation,
+            oAuthViewModel = viewModel.oAuthViewModel,
+            contentPadding = innerPadding,
+        )
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountIncomingValidationScreenK9Preview() {
+    K9Theme {
+        AccountValidationMainScreen(
+            viewModel = AccountValidationViewModel(
+                validateServerSettings = {
+                    ServerSettingsValidationResult.Success
+                },
+                accountSetupStateRepository = PreviewAccountSetupStateRepository(),
+                authorizationStateRepository = { true },
+                certificateErrorRepository = InMemoryCertificateErrorRepository(),
+                oAuthViewModel = PreviewAccountOAuthViewModel(),
+                isIncomingValidation = true,
+            ),
+        )
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountIncomingValidationScreenThunderbirdPreview() {
+    ThunderbirdTheme {
+        AccountValidationMainScreen(
+            viewModel = AccountValidationViewModel(
+                validateServerSettings = {
+                    ServerSettingsValidationResult.Success
+                },
+                accountSetupStateRepository = PreviewAccountSetupStateRepository(),
+                authorizationStateRepository = { true },
+                certificateErrorRepository = InMemoryCertificateErrorRepository(),
+                oAuthViewModel = PreviewAccountOAuthViewModel(),
+                isIncomingValidation = true,
+            ),
+        )
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountOutgoingValidationScreenK9Preview() {
+    K9Theme {
+        AccountValidationMainScreen(
+            viewModel = AccountValidationViewModel(
+                validateServerSettings = {
+                    ServerSettingsValidationResult.Success
+                },
+                accountSetupStateRepository = PreviewAccountSetupStateRepository(),
+                authorizationStateRepository = { true },
+                certificateErrorRepository = InMemoryCertificateErrorRepository(),
+                oAuthViewModel = PreviewAccountOAuthViewModel(),
+                isIncomingValidation = false,
+            ),
+        )
+    }
+}
+
+@Composable
+@DevicePreviews
+internal fun AccountOutgoingValidationScreenThunderbirdPreview() {
+    ThunderbirdTheme {
+        AccountValidationMainScreen(
+            viewModel = AccountValidationViewModel(
+                validateServerSettings = {
+                    ServerSettingsValidationResult.Success
+                },
+                accountSetupStateRepository = PreviewAccountSetupStateRepository(),
+                authorizationStateRepository = { true },
+                certificateErrorRepository = InMemoryCertificateErrorRepository(),
+                oAuthViewModel = PreviewAccountOAuthViewModel(),
+                isIncomingValidation = false,
+            ),
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/validation/AccountValidationScreen.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/validation/AccountValidationScreen.kt
new file mode 100644
index 0000000000000000000000000000000000000000..0b7de7ac321d8fc7b6249674c642d7d64ad41285
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/validation/AccountValidationScreen.kt
@@ -0,0 +1,47 @@
+package app.k9mail.feature.account.setup.ui.validation
+
+import androidx.activity.compose.BackHandler
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.ui.Modifier
+import app.k9mail.core.ui.compose.common.mvi.observe
+import app.k9mail.feature.account.setup.ui.servercertificate.CertificateErrorScreen
+import app.k9mail.feature.account.setup.ui.validation.AccountValidationContract.Effect
+import app.k9mail.feature.account.setup.ui.validation.AccountValidationContract.Event
+import app.k9mail.feature.account.setup.ui.validation.AccountValidationContract.ViewModel
+
+@Composable
+internal fun AccountValidationScreen(
+    onNext: () -> Unit,
+    onBack: () -> Unit,
+    viewModel: ViewModel,
+    modifier: Modifier = Modifier,
+) {
+    val (state, dispatch) = viewModel.observe { effect ->
+        when (effect) {
+            is Effect.NavigateNext -> onNext()
+            is Effect.NavigateBack -> onBack()
+        }
+    }
+
+    LaunchedEffect(key1 = Unit) {
+        dispatch(Event.LoadAccountSetupStateAndValidate)
+    }
+
+    BackHandler {
+        dispatch(Event.OnBackClicked)
+    }
+
+    if (state.value.error is AccountValidationContract.Error.CertificateError) {
+        CertificateErrorScreen(
+            onCertificateAccepted = { dispatch(Event.OnCertificateAccepted) },
+            onBack = { dispatch(Event.OnBackClicked) },
+            modifier = modifier,
+        )
+    } else {
+        AccountValidationMainScreen(
+            viewModel = viewModel,
+            modifier = modifier,
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/validation/AccountValidationStateMapper.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/validation/AccountValidationStateMapper.kt
new file mode 100644
index 0000000000000000000000000000000000000000..3087c7f0153c97926aa37bbb3c8729e55f6b8862
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/validation/AccountValidationStateMapper.kt
@@ -0,0 +1,13 @@
+package app.k9mail.feature.account.setup.ui.validation
+
+import app.k9mail.feature.account.setup.domain.entity.AccountSetupState
+
+internal fun AccountSetupState.toValidationState(isIncomingValidation: Boolean): AccountValidationContract.State {
+    return AccountValidationContract.State(
+        emailAddress = emailAddress,
+        serverSettings = if (isIncomingValidation) incomingServerSettings else outgoingServerSettings,
+        isLoading = false,
+        isSuccess = false,
+        error = null,
+    )
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/validation/AccountValidationStringMapper.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/validation/AccountValidationStringMapper.kt
new file mode 100644
index 0000000000000000000000000000000000000000..73a7e66ab68585a4270eaf5c5a8cea8acc4c1509
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/validation/AccountValidationStringMapper.kt
@@ -0,0 +1,29 @@
+package app.k9mail.feature.account.setup.ui.validation
+
+import android.content.res.Resources
+import app.k9mail.feature.account.setup.R
+import app.k9mail.feature.account.setup.ui.validation.AccountValidationContract.Error
+
+internal fun Error.toResourceString(resources: Resources): String {
+    return when (this) {
+        is Error.AuthenticationError -> resources.getString(
+            R.string.account_setup_settings_validation_error_authentication,
+        )
+
+        is Error.CertificateError -> resources.getString(
+            R.string.account_setup_settings_validation_error_certificate,
+        )
+
+        is Error.NetworkError -> resources.getString(
+            R.string.account_setup_settings_validation_error_network,
+        )
+
+        is Error.ServerError -> resources.getString(
+            R.string.account_setup_settings_validation_error_server,
+        )
+
+        is Error.UnknownError -> resources.getString(
+            R.string.account_setup_settings_validation_error_unknown,
+        )
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/validation/AccountValidationViewModel.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/validation/AccountValidationViewModel.kt
new file mode 100644
index 0000000000000000000000000000000000000000..f628ff65c26abf5a4f6743eb5339033d7c8bf938
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/validation/AccountValidationViewModel.kt
@@ -0,0 +1,210 @@
+package app.k9mail.feature.account.setup.ui.validation
+
+import androidx.lifecycle.viewModelScope
+import app.k9mail.core.ui.compose.common.mvi.BaseViewModel
+import app.k9mail.feature.account.oauth.domain.entity.OAuthResult
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract
+import app.k9mail.feature.account.setup.domain.DomainContract
+import app.k9mail.feature.account.setup.domain.entity.CertificateError
+import app.k9mail.feature.account.setup.domain.entity.isOAuth
+import app.k9mail.feature.account.setup.ui.validation.AccountValidationContract.Effect
+import app.k9mail.feature.account.setup.ui.validation.AccountValidationContract.Error
+import app.k9mail.feature.account.setup.ui.validation.AccountValidationContract.Event
+import app.k9mail.feature.account.setup.ui.validation.AccountValidationContract.State
+import com.fsck.k9.mail.server.ServerSettingsValidationResult
+import kotlinx.coroutines.cancelChildren
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import app.k9mail.feature.account.oauth.domain.DomainContract as OAuthDomainContract
+
+private const val CONTINUE_NEXT_DELAY = 2000L
+
+@Suppress("TooManyFunctions")
+internal class AccountValidationViewModel(
+    private val validateServerSettings: DomainContract.UseCase.ValidateServerSettings,
+    private val accountSetupStateRepository: DomainContract.AccountSetupStateRepository,
+    private val authorizationStateRepository: OAuthDomainContract.AuthorizationStateRepository,
+    private val certificateErrorRepository: DomainContract.CertificateErrorRepository,
+    override val oAuthViewModel: AccountOAuthContract.ViewModel,
+    override val isIncomingValidation: Boolean = true,
+    initialState: State? = null,
+) : BaseViewModel<State, Event, Effect>(
+    initialState = initialState ?: accountSetupStateRepository.getState().toValidationState(isIncomingValidation),
+),
+    AccountValidationContract.ViewModel {
+
+    override fun event(event: Event) {
+        when (event) {
+            Event.LoadAccountSetupStateAndValidate -> loadAccountSetupStateAndValidate()
+            is Event.OnOAuthResult -> onOAuthResult(event.result)
+            Event.ValidateServerSettings -> onValidateConfig()
+            Event.OnNextClicked -> navigateNext()
+            Event.OnBackClicked -> onBack()
+            Event.OnRetryClicked -> onRetry()
+            Event.OnCertificateAccepted -> onRetry()
+        }
+    }
+
+    private fun loadAccountSetupStateAndValidate() {
+        updateState {
+            accountSetupStateRepository.getState().toValidationState(isIncomingValidation)
+        }
+        onValidateConfig()
+    }
+
+    private fun onValidateConfig() {
+        if (state.value.isSuccess) {
+            navigateNext()
+        } else if (state.value.serverSettings.isOAuth()) {
+            checkOAuthState()
+        } else {
+            validateServerSettings()
+        }
+    }
+
+    private fun checkOAuthState() {
+        val authorizationState = accountSetupStateRepository.getState().authorizationState
+        if (authorizationState != null) {
+            if (authorizationStateRepository.isAuthorized(authorizationState)) {
+                validateServerSettings()
+            } else {
+                startOAuthSignIn()
+            }
+        } else {
+            startOAuthSignIn()
+        }
+    }
+
+    private fun startOAuthSignIn() {
+        val hostname = state.value.serverSettings?.host
+        val emailAddress = state.value.emailAddress
+
+        if (hostname == null || emailAddress == null) {
+            updateError(Error.UnknownError("Hostname or email address not set"))
+            return
+        } else {
+            updateState { state ->
+                state.copy(
+                    needsAuthorization = true,
+                )
+            }
+
+            oAuthViewModel.initState(
+                AccountOAuthContract.State(
+                    hostname = hostname,
+                    emailAddress = emailAddress,
+                ),
+            )
+        }
+    }
+
+    private fun onOAuthResult(result: OAuthResult) {
+        if (result is OAuthResult.Success) {
+            accountSetupStateRepository.saveAuthorizationState(result.authorizationState)
+            updateState {
+                it.copy(
+                    needsAuthorization = false,
+                )
+            }
+
+            validateServerSettings()
+        }
+    }
+
+    private fun validateServerSettings() {
+        viewModelScope.launch {
+            val serverSettings = state.value.serverSettings
+            if (serverSettings == null) {
+                updateError(Error.UnknownError("Server settings not set"))
+                return@launch
+            }
+
+            updateState {
+                it.copy(isLoading = true)
+            }
+
+            when (val result = validateServerSettings.execute(serverSettings)) {
+                ServerSettingsValidationResult.Success -> updateSuccess()
+
+                is ServerSettingsValidationResult.AuthenticationError -> updateError(
+                    Error.AuthenticationError(result.serverMessage),
+                )
+
+                is ServerSettingsValidationResult.CertificateError -> updateError(
+                    Error.CertificateError(result.certificateChain),
+                )
+
+                is ServerSettingsValidationResult.NetworkError -> updateError(
+                    Error.NetworkError(result.exception),
+                )
+
+                is ServerSettingsValidationResult.ServerError -> updateError(
+                    Error.ServerError(result.serverMessage),
+                )
+
+                is ServerSettingsValidationResult.UnknownError -> updateError(
+                    Error.UnknownError(result.exception.message ?: "Unknown error"),
+                )
+            }
+        }
+    }
+
+    private fun updateSuccess() {
+        updateState {
+            it.copy(
+                isLoading = false,
+                isSuccess = true,
+            )
+        }
+
+        viewModelScope.launch {
+            delay(CONTINUE_NEXT_DELAY)
+            navigateNext()
+        }
+    }
+
+    private fun updateError(error: Error) {
+        if (error is Error.CertificateError) {
+            val serverSettings = checkNotNull(state.value.serverSettings)
+
+            certificateErrorRepository.setCertificateError(
+                CertificateError(
+                    hostname = serverSettings.host!!,
+                    port = serverSettings.port,
+                    certificateChain = error.certificateChain,
+                ),
+            )
+        }
+
+        updateState {
+            it.copy(
+                error = error,
+                isLoading = false,
+                isSuccess = false,
+            )
+        }
+    }
+
+    private fun onBack() {
+        navigateBack()
+    }
+
+    private fun onRetry() {
+        updateState {
+            it.copy(
+                error = null,
+            )
+        }
+        onValidateConfig()
+    }
+
+    private fun navigateBack() {
+        viewModelScope.coroutineContext.cancelChildren()
+        emitEffect(Effect.NavigateBack)
+    }
+
+    private fun navigateNext() {
+        viewModelScope.coroutineContext.cancelChildren()
+        emitEffect(Effect.NavigateNext)
+    }
+}
diff --git a/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/validation/InMemoryAuthStateStorage.kt b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/validation/InMemoryAuthStateStorage.kt
new file mode 100644
index 0000000000000000000000000000000000000000..b151b4ccacd4af103adedf247fa8c13fafd049ba
--- /dev/null
+++ b/feature/account/setup/src/main/kotlin/app/k9mail/feature/account/setup/ui/validation/InMemoryAuthStateStorage.kt
@@ -0,0 +1,21 @@
+package app.k9mail.feature.account.setup.ui.validation
+
+import com.fsck.k9.mail.oauth.AuthStateStorage
+
+class InMemoryAuthStateStorage : AuthStateStorage {
+    private var authorizationState: String? = null
+
+    @Synchronized
+    override fun getAuthorizationState(): String? {
+        return authorizationState
+    }
+
+    @Synchronized
+    override fun updateAuthorizationState(authorizationState: String?) {
+        this.authorizationState = authorizationState
+    }
+
+    override fun getEmail(): String? {
+        return null
+    }
+}
diff --git a/feature/account/setup/src/main/res/values/plurals.xml b/feature/account/setup/src/main/res/values/plurals.xml
new file mode 100644
index 0000000000000000000000000000000000000000..2eb78563a6051604deee389c2746aba9c06b7286
--- /dev/null
+++ b/feature/account/setup/src/main/res/values/plurals.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <plurals name="account_setup_options_email_check_frequency_minutes">
+        <item quantity="one">Every minute</item>
+        <item quantity="other">Every %d minutes</item>
+    </plurals>
+    <plurals name="account_setup_options_email_check_frequency_hours">
+        <item quantity="one">Every hour</item>
+        <item quantity="other">Every %d hours</item>
+    </plurals>
+    <plurals name="account_setup_options_email_display_count_messages">
+        <item quantity="one">1 message</item>
+        <item quantity="other">%d messages</item>
+    </plurals>
+</resources>
diff --git a/feature/account/setup/src/main/res/values/strings.xml b/feature/account/setup/src/main/res/values/strings.xml
index ae5657699238bed0b404f93fc4fbad3b828daed7..4546ad2c94b094ab4dc819cee85e629ed4c69b1c 100644
--- a/feature/account/setup/src/main/res/values/strings.xml
+++ b/feature/account/setup/src/main/res/values/strings.xml
@@ -4,4 +4,82 @@
     <string name="account_setup_button_next">Next</string>
     <string name="account_setup_button_back">Back</string>
     <string name="account_setup_button_finish">Finish</string>
+    <string name="account_setup_connection_security_none">None</string>
+    <string name="account_setup_connection_security_ssl">SSL/TLS</string>
+    <string name="account_setup_connection_security_start_tls">StartTLS</string>
+    <string name="account_setup_authentication_none">None</string>
+    <string name="account_setup_authentication_password_cleartext">Normal password</string>
+    <string name="account_setup_authentication_password_encrypted">Encrypted password</string>
+    <string name="account_setup_authentication_client_certificate">Client certificate</string>
+    <string name="account_setup_authentication_client_oauth">OAuth 2.0</string>
+    <string name="account_setup_client_certificate_label">Client certificate</string>
+    <string name="account_setup_client_certificate_none_selected">None</string>
+
+    <string name="account_setup_error_network">Network </string>
+    <string name="account_setup_error_unknown">Unknown error</string>
+
+    <string name="account_setup_validation_error_email_address_required">Email address is required.</string>
+    <string name="account_setup_validation_error_email_address_invalid">Email address is invalid.</string>
+    <string name="account_setup_validation_error_server_required">Server name is required.</string>
+    <string name="account_setup_validation_error_port_required">Port is required.</string>
+    <string name="account_setup_validation_error_port_invalid">Port is invalid (must be 1–65535).</string>
+    <string name="account_setup_validation_error_username_required">Username is required.</string>
+    <string name="account_setup_validation_error_password_required">Password is required.</string>
+    <string name="account_setup_validation_error_imap_prefix_blank">Imap prefix can\'t be blank.</string>
+
+    <string name="account_setup_settings_validation_error_authentication">Authentication error</string>
+    <string name="account_setup_settings_validation_error_certificate">Certificate error</string>
+    <string name="account_setup_settings_validation_error_network">Network error</string>
+    <string name="account_setup_settings_validation_error_server">Server error</string>
+    <string name="account_setup_settings_validation_error_unknown">Unknown error</string>
+    <string name="account_setup_settings_validation_incoming_loading_message">Checking incoming server settings…</string>
+    <string name="account_setup_settings_validation_incoming_loading_error">Checking incoming server settings failed!</string>
+    <string name="account_setup_settings_validation_incoming_success">Incoming server settings are valid!</string>
+    <string name="account_setup_settings_validation_outgoing_loading_message">Checking outgoing server settings…</string>
+    <string name="account_setup_settings_validation_outgoing_loading_error">Checking outgoing server settings failed!</string>
+    <string name="account_setup_settings_validation_outgoing_success">Outgoing server settings are valid!</string>
+    <string name="account_setup_settings_validation_sign_in">Please sign in</string>
+
+    <string name="account_setup_auto_config_loading_message">Finding email details</string>
+    <string name="account_setup_auto_config_loading_error">Failed to load email configuration</string>
+    <string name="account_setup_auto_config_status_header_title_configuration_found">Configuration Found</string>
+    <string name="account_setup_auto_config_status_header_title_configuration_not_found">Configuration Not Found</string>
+    <string name="account_setup_auto_config_status_header_subtitle_configuration_trusted">Configure automatically</string>
+    <string name="account_setup_auto_config_status_header_subtitle_configuration_untrusted">This configuration is not trusted</string>
+    <string name="account_setup_auto_config_status_disclaimer_untrusted_configuration">We received the configuration for your email server over a connection that isn\'t as secure as we\'d like. This means that there is a tiny chance that someone could have altered it. Could you please double-check the provided configuration to make sure it\'s as it should be?</string>
+    <string name="account_setup_auto_config_status_header_subtitle_configuration_not_found">Configure manually</string>
+    <string name="account_setup_auto_config_status_edit_configuration_button_label">Edit configuration</string>
+    <string name="account_setup_auto_config_status_checkbox_configuration_untrusted_confirmation_label">I trust this configuration</string>
+    <string name="account_setup_error_configuration_approval_required">It is required to approve the configuration.</string>
+
+    <string name="account_setup_incoming_config_top_bar_title">Incoming server settings</string>
+    <string name="account_setup_incoming_config_protocol_type_label">Protocol</string>
+    <string name="account_setup_incoming_config_server_label">Server</string>
+    <string name="account_setup_incoming_config_security_label">Security</string>
+    <string name="account_setup_incoming_config_authentication_label">Authentication</string>
+    <string name="account_setup_incoming_config_imap_namespace_label">Auto-detect IMAP namespace</string>
+    <string name="account_setup_incoming_config_imap_prefix_label">IMAP path prefix</string>
+    <string name="account_setup_incoming_config_imap_compression_label">Use compression</string>
+    <string name="account_setup_incoming_config_imap_send_client_id_label">Send client ID</string>
+
+    <string name="account_setup_outgoing_config_top_bar_title">Outgoing server settings</string>
+    <string name="account_setup_outgoing_config_server_label">Server</string>
+    <string name="account_setup_outgoing_config_security_label">Security</string>
+    <string name="account_setup_outgoing_config_port_label">Port</string>
+    <string name="account_setup_outgoing_config_authentication_label">Authentication</string>
+    <string name="account_setup_outgoing_config_username_label">Username</string>
+
+    <string name="account_setup_options_top_bar_title">Account options</string>
+    <string name="account_setup_options_section_display_options">Display options</string>
+    <string name="account_setup_options_account_name_label">Account name</string>
+    <string name="account_setup_options_account_name_error_blank">Account name can\'t be blank.</string>
+    <string name="account_setup_options_display_name_label">Display name</string>
+    <string name="account_setup_options_display_name_error_required">Display name is required.</string>
+    <string name="account_setup_options_email_signature_label">Email signature</string>
+    <string name="account_setup_options_email_signature_error_blank">Email signature name can\'t be blank.</string>
+    <string name="account_setup_options_section_sync_options_">Sync options</string>
+    <string name="account_setup_options_account_check_frequency_label">Check frequency</string>
+    <string name="account_setup_options_email_check_frequency_never">Never</string>
+    <string name="account_setup_options_email_display_count_label">Number of messages to display</string>
+    <string name="account_setup_options_show_notifications_label">Show notifications</string>
 </resources>
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/AccountSetupModuleKtTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/AccountSetupModuleKtTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c5552ff0f152226ad32e2e983e0ba4996d07c529
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/AccountSetupModuleKtTest.kt
@@ -0,0 +1,86 @@
+package app.k9mail.feature.account.setup
+
+import android.content.Context
+import app.k9mail.core.common.oauth.OAuthConfigurationFactory
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract
+import app.k9mail.feature.account.setup.AccountSetupExternalContract.AccountCreator
+import app.k9mail.feature.account.setup.AccountSetupExternalContract.AccountCreator.AccountCreatorResult
+import app.k9mail.feature.account.setup.domain.entity.AccountSetupState
+import app.k9mail.feature.account.setup.ui.AccountSetupContract
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract
+import app.k9mail.feature.account.setup.ui.servercertificate.CertificateErrorContract
+import app.k9mail.feature.account.setup.ui.validation.AccountValidationContract
+import com.fsck.k9.mail.oauth.AuthStateStorage
+import com.fsck.k9.mail.oauth.OAuth2TokenProvider
+import com.fsck.k9.mail.oauth.OAuth2TokenProviderFactory
+import com.fsck.k9.mail.ssl.LocalKeyStore
+import com.fsck.k9.mail.ssl.TrustedSocketFactory
+import okhttp3.OkHttpClient
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.koin.android.ext.koin.androidContext
+import org.koin.core.annotation.KoinExperimentalAPI
+import org.koin.core.module.Module
+import org.koin.dsl.koinApplication
+import org.koin.dsl.module
+import org.koin.test.KoinTest
+import org.koin.test.check.checkModules
+import org.koin.test.verify.verify
+import org.mockito.Mockito.mock
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+
+@OptIn(KoinExperimentalAPI::class)
+@RunWith(RobolectricTestRunner::class)
+class AccountSetupModuleKtTest : KoinTest {
+
+    private val externalModule: Module = module {
+        single<OkHttpClient> { OkHttpClient() }
+        single<TrustedSocketFactory> {
+            TrustedSocketFactory { _, _, _, _ -> null }
+        }
+        single<AccountCreator> {
+            AccountCreator { _ -> AccountCreatorResult.Success("accountUuid") }
+        }
+        single<OAuthConfigurationFactory> { OAuthConfigurationFactory { emptyMap() } }
+        single<OAuth2TokenProviderFactory> {
+            OAuth2TokenProviderFactory { _ ->
+                object : OAuth2TokenProvider {
+                    override fun getToken(timeoutMillis: Long) = TODO()
+                    override fun invalidateToken() = TODO()
+                }
+            }
+        }
+        single<LocalKeyStore> { mock() }
+    }
+
+    @Test
+    fun `should have a valid di module`() {
+        featureAccountSetupModule.verify(
+            extraTypes = listOf(
+                AccountSetupContract.State::class,
+                AccountAutoDiscoveryContract.State::class,
+                AccountOAuthContract.State::class,
+                AccountValidationContract.State::class,
+                AccountIncomingConfigContract.State::class,
+                AccountOutgoingConfigContract.State::class,
+                AccountOptionsContract.State::class,
+                AccountSetupState::class,
+                CertificateErrorContract.State::class,
+                AuthStateStorage::class,
+                Context::class,
+                Boolean::class,
+                Class.forName("net.openid.appauth.AppAuthConfiguration").kotlin,
+            ),
+        )
+
+        koinApplication {
+            modules(externalModule, featureAccountSetupModule)
+            androidContext(RuntimeEnvironment.getApplication())
+            checkModules()
+        }
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/data/InMemoryAccountSetupStateRepositoryTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/data/InMemoryAccountSetupStateRepositoryTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..a234017f2b14dc7362460a93bab5d4fa6584bb1c
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/data/InMemoryAccountSetupStateRepositoryTest.kt
@@ -0,0 +1,170 @@
+package app.k9mail.feature.account.setup.data
+
+import app.k9mail.feature.account.oauth.domain.entity.AuthorizationState
+import app.k9mail.feature.account.setup.domain.entity.AccountOptions
+import app.k9mail.feature.account.setup.domain.entity.AccountSetupState
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import com.fsck.k9.mail.AuthType
+import com.fsck.k9.mail.ConnectionSecurity
+import com.fsck.k9.mail.ServerSettings
+import org.junit.Test
+
+class InMemoryAccountSetupStateRepositoryTest {
+
+    @Test
+    fun `should initialize with empty state`() {
+        val testSubject = InMemoryAccountSetupStateRepository()
+
+        val result = testSubject.getState()
+
+        assertThat(result).isEqualTo(
+            AccountSetupState(
+                emailAddress = null,
+                incomingServerSettings = null,
+                outgoingServerSettings = null,
+                authorizationState = null,
+                options = null,
+            ),
+        )
+    }
+
+    @Test
+    fun `should save state`() {
+        val testSubject = InMemoryAccountSetupStateRepository(
+            AccountSetupState(
+                emailAddress = "emailAddress",
+                incomingServerSettings = INCOMING_SERVER_SETTINGS,
+                outgoingServerSettings = OUTGOING_SERVER_SETTINGS,
+                authorizationState = AuthorizationState("authorizationState"),
+                options = OPTIONS,
+            ),
+        )
+        val newState = AccountSetupState(
+            emailAddress = "emailAddress2",
+            incomingServerSettings = INCOMING_SERVER_SETTINGS.copy(host = "imap2.example.org"),
+            outgoingServerSettings = OUTGOING_SERVER_SETTINGS.copy(host = "smtp2.example.org"),
+            authorizationState = AuthorizationState("authorizationState2"),
+            options = OPTIONS.copy(
+                accountName = "accountName2",
+                displayName = "displayName2",
+                emailSignature = "emailSignature2",
+                checkFrequencyInMinutes = 50,
+                messageDisplayCount = 60,
+                showNotification = false,
+            ),
+        )
+
+        testSubject.save(newState)
+
+        assertThat(testSubject.getState()).isEqualTo(newState)
+    }
+
+    @Test
+    fun `should save email address`() {
+        val testSubject = InMemoryAccountSetupStateRepository()
+
+        testSubject.saveEmailAddress("emailAddress")
+
+        assertThat(testSubject.getState().emailAddress)
+            .isEqualTo("emailAddress")
+    }
+
+    @Test
+    fun `should save incoming server settings`() {
+        val testSubject = InMemoryAccountSetupStateRepository()
+
+        testSubject.saveIncomingServerSettings(INCOMING_SERVER_SETTINGS)
+
+        assertThat(testSubject.getState().incomingServerSettings)
+            .isEqualTo(INCOMING_SERVER_SETTINGS)
+    }
+
+    @Test
+    fun `should save outgoing server settings`() {
+        val testSubject = InMemoryAccountSetupStateRepository()
+
+        testSubject.saveOutgoingServerSettings(OUTGOING_SERVER_SETTINGS)
+
+        assertThat(testSubject.getState().outgoingServerSettings)
+            .isEqualTo(OUTGOING_SERVER_SETTINGS)
+    }
+
+    @Test
+    fun `should save authorization state`() {
+        val testSubject = InMemoryAccountSetupStateRepository()
+
+        testSubject.saveAuthorizationState(AuthorizationState("authorizationState"))
+
+        assertThat(testSubject.getState().authorizationState)
+            .isEqualTo(AuthorizationState("authorizationState"))
+    }
+
+    @Test
+    fun `should save options`() {
+        val testSubject = InMemoryAccountSetupStateRepository()
+
+        testSubject.saveOptions(OPTIONS)
+
+        assertThat(testSubject.getState().options)
+            .isEqualTo(OPTIONS)
+    }
+
+    @Test
+    fun `should clear state`() {
+        val testSubject = InMemoryAccountSetupStateRepository(
+            AccountSetupState(
+                emailAddress = "emailAddress",
+                incomingServerSettings = INCOMING_SERVER_SETTINGS,
+                outgoingServerSettings = OUTGOING_SERVER_SETTINGS,
+                authorizationState = AuthorizationState("authorizationState"),
+                options = OPTIONS,
+            ),
+        )
+
+        testSubject.clear()
+
+        assertThat(testSubject.getState()).isEqualTo(
+            AccountSetupState(
+                emailAddress = null,
+                incomingServerSettings = null,
+                outgoingServerSettings = null,
+                authorizationState = null,
+                options = null,
+            ),
+        )
+    }
+
+    private companion object {
+        val INCOMING_SERVER_SETTINGS = ServerSettings(
+            "imap",
+            "imap.example.org",
+            993,
+            ConnectionSecurity.SSL_TLS_REQUIRED,
+            AuthType.PLAIN,
+            "username",
+            "password",
+            null,
+        )
+
+        val OUTGOING_SERVER_SETTINGS = ServerSettings(
+            "smtp",
+            "smtp.example.org",
+            465,
+            ConnectionSecurity.SSL_TLS_REQUIRED,
+            AuthType.PLAIN,
+            "username",
+            "password",
+            null,
+        )
+
+        val OPTIONS = AccountOptions(
+            accountName = "accountName",
+            displayName = "displayName",
+            emailSignature = "emailSignature",
+            checkFrequencyInMinutes = 10,
+            messageDisplayCount = 20,
+            showNotification = true,
+        )
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/AutoDiscoveryMapperKtTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/AutoDiscoveryMapperKtTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..4a9f0cecfe8fb9a330f3a41557161aa258897a77
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/AutoDiscoveryMapperKtTest.kt
@@ -0,0 +1,94 @@
+package app.k9mail.feature.account.setup.domain
+
+import app.k9mail.autodiscovery.api.AuthenticationType
+import app.k9mail.autodiscovery.api.ConnectionSecurity
+import app.k9mail.autodiscovery.api.ImapServerSettings
+import app.k9mail.autodiscovery.api.IncomingServerSettings
+import app.k9mail.autodiscovery.api.OutgoingServerSettings
+import app.k9mail.autodiscovery.api.SmtpServerSettings
+import app.k9mail.core.common.net.Hostname
+import app.k9mail.core.common.net.Port
+import app.k9mail.feature.account.setup.domain.entity.MailConnectionSecurity
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import com.fsck.k9.mail.AuthType
+import com.fsck.k9.mail.ServerSettings
+import kotlin.test.assertFailsWith
+import org.junit.Test
+
+class AutoDiscoveryMapperKtTest {
+
+    @Test
+    fun `should map IncomingServerSettings to ServerSettings`() {
+        val incomingServerSettings = ImapServerSettings(
+            hostname = Hostname("imap.example.org"),
+            port = Port(993),
+            connectionSecurity = ConnectionSecurity.TLS,
+            authenticationTypes = listOf(AuthenticationType.PasswordCleartext),
+            username = "user",
+        )
+        val password = "password"
+
+        val serverSettings = incomingServerSettings.toServerSettings(password)
+
+        assertThat(serverSettings).isEqualTo(
+            ServerSettings(
+                type = "imap",
+                host = "imap.example.org",
+                port = 993,
+                connectionSecurity = MailConnectionSecurity.SSL_TLS_REQUIRED,
+                authenticationType = AuthType.PLAIN,
+                username = "user",
+                password = "password",
+                clientCertificateAlias = null,
+                extra = emptyMap(),
+            ),
+        )
+    }
+
+    @Test
+    fun `should throw error when IncomingServerSettings not known`() {
+        val incomingServerSettings = object : IncomingServerSettings {}
+
+        assertFailsWith<IllegalArgumentException> {
+            incomingServerSettings.toServerSettings("password")
+        }
+    }
+
+    @Test
+    fun `should map OutgoingServerSettings to ServerSettings`() {
+        val outgoingServerSettings = SmtpServerSettings(
+            hostname = Hostname("smtp.example.org"),
+            port = Port(587),
+            connectionSecurity = ConnectionSecurity.StartTLS,
+            authenticationTypes = listOf(AuthenticationType.PasswordCleartext),
+            username = "user",
+        )
+        val password = "password"
+
+        val serverSettings = outgoingServerSettings.toServerSettings(password)
+
+        assertThat(serverSettings).isEqualTo(
+            ServerSettings(
+                type = "smtp",
+                host = "smtp.example.org",
+                port = 587,
+                connectionSecurity = MailConnectionSecurity.STARTTLS_REQUIRED,
+                authenticationType = AuthType.PLAIN,
+                username = "user",
+                password = "password",
+                clientCertificateAlias = null,
+                extra = emptyMap(),
+            ),
+        )
+    }
+
+    @Test
+    fun `should throw error when OutgoingServerSettings not known`() {
+        val outgoingServerSettings = object : OutgoingServerSettings {}
+
+        assertFailsWith<IllegalArgumentException> {
+            outgoingServerSettings.toServerSettings("password")
+        }
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/AuthenticationTypeTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/AuthenticationTypeTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..72dc05926196ce7338e94a1454f2de92b6b22a1d
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/AuthenticationTypeTest.kt
@@ -0,0 +1,47 @@
+package app.k9mail.feature.account.setup.domain.entity
+
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import com.fsck.k9.mail.AuthType
+import org.junit.Test
+
+class AuthenticationTypeTest {
+
+    @Test
+    fun `should map all AuthenticationType to AuthTypes`() {
+        val types = AuthenticationType.values()
+
+        for (type in types) {
+            val authType = type.toAuthType()
+
+            assertThat(authType).isEqualTo(
+                when (type) {
+                    AuthenticationType.PasswordCleartext -> AuthType.PLAIN
+                    AuthenticationType.PasswordEncrypted -> AuthType.CRAM_MD5
+                    AuthenticationType.OAuth2 -> AuthType.XOAUTH2
+                    AuthenticationType.ClientCertificate -> AuthType.EXTERNAL
+                    else -> AuthType.PLAIN
+                },
+            )
+        }
+    }
+
+    @Test
+    fun `should map all AuthTypes to AuthenticationTypes`() {
+        val types = AuthType.values()
+
+        for (type in types) {
+            val authenticationType = type.toAuthenticationType()
+
+            assertThat(authenticationType).isEqualTo(
+                when (type) {
+                    AuthType.PLAIN -> AuthenticationType.PasswordCleartext
+                    AuthType.CRAM_MD5 -> AuthenticationType.PasswordEncrypted
+                    AuthType.EXTERNAL -> AuthenticationType.ClientCertificate
+                    AuthType.XOAUTH2 -> AuthenticationType.OAuth2
+                    else -> AuthenticationType.None
+                },
+            )
+        }
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/AutoDiscoveryAuthenticationTypeKtTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/AutoDiscoveryAuthenticationTypeKtTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..9f71df260592b73625babe78f0e10aaec1fe44a1
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/AutoDiscoveryAuthenticationTypeKtTest.kt
@@ -0,0 +1,25 @@
+package app.k9mail.feature.account.setup.domain.entity
+
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import org.junit.Test
+
+class AutoDiscoveryAuthenticationTypeKtTest {
+
+    @Test
+    fun `should map all AutoDiscoveryAuthenticationTypes`() {
+        val types = AutoDiscoveryAuthenticationType.values()
+
+        for (type in types) {
+            val authenticationType = type.toAuthenticationType()
+
+            assertThat(authenticationType).isEqualTo(
+                when (type) {
+                    AutoDiscoveryAuthenticationType.PasswordCleartext -> AuthenticationType.PasswordCleartext
+                    AutoDiscoveryAuthenticationType.PasswordEncrypted -> AuthenticationType.PasswordEncrypted
+                    AutoDiscoveryAuthenticationType.OAuth2 -> AuthenticationType.OAuth2
+                },
+            )
+        }
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/AutoDiscoveryConnectionSecurityKtTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/AutoDiscoveryConnectionSecurityKtTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..0901951aab584c14099e25ad8aa345c12f6ea6d3
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/AutoDiscoveryConnectionSecurityKtTest.kt
@@ -0,0 +1,24 @@
+package app.k9mail.feature.account.setup.domain.entity
+
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import org.junit.Test
+
+class AutoDiscoveryConnectionSecurityKtTest {
+
+    @Test
+    fun `should map all AutoDiscoveryConnectionSecurities`() {
+        val securities = AutoDiscoveryConnectionSecurity.values()
+
+        for (security in securities) {
+            val connectionSecurity = security.toConnectionSecurity()
+
+            assertThat(connectionSecurity).isEqualTo(
+                when (security) {
+                    AutoDiscoveryConnectionSecurity.StartTLS -> ConnectionSecurity.StartTLS
+                    AutoDiscoveryConnectionSecurity.TLS -> ConnectionSecurity.TLS
+                },
+            )
+        }
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/AutoDiscoverySettingsFixture.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/AutoDiscoverySettingsFixture.kt
new file mode 100644
index 0000000000000000000000000000000000000000..cb3cf6b72ec18d7e241cb440ac799cfdc3c7bf59
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/AutoDiscoverySettingsFixture.kt
@@ -0,0 +1,31 @@
+package app.k9mail.feature.account.setup.domain.entity
+
+import app.k9mail.autodiscovery.api.AuthenticationType
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.autodiscovery.api.ConnectionSecurity
+import app.k9mail.autodiscovery.api.ImapServerSettings
+import app.k9mail.autodiscovery.api.SmtpServerSettings
+import app.k9mail.core.common.net.toHostname
+import app.k9mail.core.common.net.toPort
+
+object AutoDiscoverySettingsFixture {
+
+    val settings = AutoDiscoveryResult.Settings(
+        incomingServerSettings = ImapServerSettings(
+            hostname = "incoming.example.com".toHostname(),
+            port = 123.toPort(),
+            connectionSecurity = ConnectionSecurity.TLS,
+            authenticationTypes = listOf(AuthenticationType.PasswordEncrypted),
+            username = "incoming_username",
+        ),
+        outgoingServerSettings = SmtpServerSettings(
+            hostname = "outgoing.example.com".toHostname(),
+            port = 456.toPort(),
+            connectionSecurity = ConnectionSecurity.TLS,
+            authenticationTypes = listOf(AuthenticationType.PasswordEncrypted),
+            username = "outgoing_username",
+        ),
+        isTrusted = true,
+        source = "test",
+    )
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/ConnectionSecurityTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/ConnectionSecurityTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..0f74a657ca524d0e794d0ecbdc2c533eb685ed6f
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/ConnectionSecurityTest.kt
@@ -0,0 +1,93 @@
+package app.k9mail.feature.account.setup.domain.entity
+
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import org.junit.Test
+
+class ConnectionSecurityTest {
+
+    @Test
+    fun `should provide right default smtp port`() {
+        val connectionSecurities = ConnectionSecurity.all()
+
+        for (security in connectionSecurities) {
+            val port = security.toSmtpDefaultPort()
+
+            assertThat(port).isEqualTo(
+                when (security) {
+                    ConnectionSecurity.None -> 587L
+                    ConnectionSecurity.StartTLS -> 587L
+                    ConnectionSecurity.TLS -> 465L
+                },
+            )
+        }
+    }
+
+    @Test
+    fun `should provide right default imap port`() {
+        val connectionSecurities = ConnectionSecurity.all()
+
+        for (security in connectionSecurities) {
+            val port = security.toImapDefaultPort()
+
+            assertThat(port).isEqualTo(
+                when (security) {
+                    ConnectionSecurity.None -> 143L
+                    ConnectionSecurity.StartTLS -> 143L
+                    ConnectionSecurity.TLS -> 993L
+                },
+            )
+        }
+    }
+
+    @Test
+    fun `should provide right default pop3 port`() {
+        val connectionSecurities = ConnectionSecurity.all()
+
+        for (security in connectionSecurities) {
+            val port = security.toPop3DefaultPort()
+
+            assertThat(port).isEqualTo(
+                when (security) {
+                    ConnectionSecurity.None -> 110L
+                    ConnectionSecurity.StartTLS -> 110L
+                    ConnectionSecurity.TLS -> 995L
+                },
+            )
+        }
+    }
+
+    @Test
+    fun `should map all MailConnectionSecurities to ConnectionSecurities`() {
+        val securities = MailConnectionSecurity.values()
+
+        for (security in securities) {
+            val connectionSecurity = security.toConnectionSecurity()
+
+            assertThat(connectionSecurity).isEqualTo(
+                when (security) {
+                    MailConnectionSecurity.NONE -> ConnectionSecurity.None
+                    MailConnectionSecurity.STARTTLS_REQUIRED -> ConnectionSecurity.StartTLS
+                    MailConnectionSecurity.SSL_TLS_REQUIRED -> ConnectionSecurity.TLS
+                },
+            )
+        }
+    }
+
+    @Test
+    fun `should map to all ConnectionSecurities to MailConnectionSecurities`() {
+        val connectionSecurities = ConnectionSecurity.values()
+
+        for (security in connectionSecurities) {
+            val mailConnectionSecurity = security.toMailConnectionSecurity()
+
+            assertThat(mailConnectionSecurity).isEqualTo(
+                when (security) {
+                    ConnectionSecurity.None -> MailConnectionSecurity.NONE
+                    ConnectionSecurity.StartTLS -> MailConnectionSecurity.STARTTLS_REQUIRED
+                    ConnectionSecurity.TLS -> MailConnectionSecurity.SSL_TLS_REQUIRED
+                },
+            )
+        }
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/IncomingProtocolTypeTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/IncomingProtocolTypeTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d10da4c8faa494bb6a7e6b8b23b10dcea17c28bb
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/IncomingProtocolTypeTest.kt
@@ -0,0 +1,56 @@
+package app.k9mail.feature.account.setup.domain.entity
+
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import kotlin.test.assertFailsWith
+import org.junit.Test
+
+class IncomingProtocolTypeTest {
+
+    @Test
+    fun `all should contain all protocol types`() {
+        val protocolTypes = IncomingProtocolType.all()
+
+        assertThat(protocolTypes).isEqualTo(
+            IncomingProtocolType.values().toList(),
+        )
+    }
+
+    @Test
+    fun `fromName should return right protocol type`() {
+        val protocolType = IncomingProtocolType.fromName("imap")
+
+        assertThat(protocolType).isEqualTo(IncomingProtocolType.IMAP)
+    }
+
+    @Test
+    fun `fromName should throw IllegalArgumentException`() {
+        assertFailsWith<IllegalArgumentException> { IncomingProtocolType.fromName("unknown") }
+    }
+
+    @Test
+    fun `defaultConnectionSecurity should provide right default connection security`() {
+        val protocolTypeToConnectionSecurity = IncomingProtocolType.all()
+            .associateWith { it.defaultConnectionSecurity }
+
+        assertThat(protocolTypeToConnectionSecurity).isEqualTo(
+            mapOf(
+                IncomingProtocolType.IMAP to ConnectionSecurity.TLS,
+                IncomingProtocolType.POP3 to ConnectionSecurity.TLS,
+            ),
+        )
+    }
+
+    @Test
+    fun `should provide right default port`() {
+        val protocolTypeToPort = IncomingProtocolType.all()
+            .associateWith { it.toDefaultPort(it.defaultConnectionSecurity) }
+
+        assertThat(protocolTypeToPort).isEqualTo(
+            mapOf(
+                IncomingProtocolType.IMAP to 993L,
+                IncomingProtocolType.POP3 to 995L,
+            ),
+        )
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/IncomingServerSettingsExtensionKtTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/IncomingServerSettingsExtensionKtTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..89206a0f2cf8cd9081e670d5d2cbb684aa94439b
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/IncomingServerSettingsExtensionKtTest.kt
@@ -0,0 +1,25 @@
+package app.k9mail.feature.account.setup.domain.entity
+
+import app.k9mail.autodiscovery.api.AuthenticationType
+import app.k9mail.autodiscovery.api.ImapServerSettings
+import app.k9mail.core.common.net.toHostname
+import app.k9mail.core.common.net.toPort
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import org.junit.Test
+
+class IncomingServerSettingsExtensionKtTest {
+
+    @Test
+    fun `should map all ImapServerSettings to IncomingProtocolType IMAP`() {
+        val imapServerSettings = ImapServerSettings(
+            hostname = "example.com".toHostname(),
+            port = 993.toPort(),
+            connectionSecurity = AutoDiscoveryConnectionSecurity.TLS,
+            authenticationTypes = listOf(AuthenticationType.PasswordCleartext),
+            username = "username",
+        )
+
+        assertThat(imapServerSettings.toIncomingProtocolType()).isEqualTo(IncomingProtocolType.IMAP)
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/OutgoingProtocolTypeTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/OutgoingProtocolTypeTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..33afc43d1ad325bef557344232b9a7ba9aa32658
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/entity/OutgoingProtocolTypeTest.kt
@@ -0,0 +1,40 @@
+package app.k9mail.feature.account.setup.domain.entity
+
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import org.junit.Test
+
+class OutgoingProtocolTypeTest {
+
+    @Test
+    fun `all should contain all protocol types`() {
+        val protocolTypes = OutgoingProtocolType.all()
+
+        assertThat(protocolTypes).isEqualTo(
+            OutgoingProtocolType.values().toList(),
+        )
+    }
+
+    @Test
+    fun `defaultConnectionSecurity should provide right default connection security`() {
+        val protocolTypeToConnectionSecurity = OutgoingProtocolType.all().associateWith { it.defaultConnectionSecurity }
+
+        assertThat(protocolTypeToConnectionSecurity).isEqualTo(
+            mapOf(
+                OutgoingProtocolType.SMTP to ConnectionSecurity.TLS,
+            ),
+        )
+    }
+
+    @Test
+    fun `should provide right default port`() {
+        val protocolTypeToPort = OutgoingProtocolType.all()
+            .associateWith { it.toDefaultPort(it.defaultConnectionSecurity) }
+
+        assertThat(protocolTypeToPort).isEqualTo(
+            mapOf(
+                OutgoingProtocolType.SMTP to 465L,
+            ),
+        )
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/input/InputFieldTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/input/InputFieldTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..af3ae423eaa2e89040cd87d07ec7f18c70093887
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/input/InputFieldTest.kt
@@ -0,0 +1,261 @@
+package app.k9mail.feature.account.setup.domain.input
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import assertk.Assert
+import assertk.all
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.isFalse
+import assertk.assertions.isNotSameAs
+import assertk.assertions.isNull
+import assertk.assertions.isSameAs
+import assertk.assertions.isTrue
+import assertk.assertions.prop
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.Parameterized
+
+data class InputFieldTestData<T>(
+    val name: String,
+    val initialState: InputField<T>,
+    val initialValue: T,
+    val initialValueEmpty: T,
+    val initialError: ValidationError?,
+    val initialIsValid: Boolean,
+    val createInitialInput: (value: T, error: ValidationError?, isValid: Boolean) -> InputField<T>,
+    val updatedValue: T,
+)
+
+@RunWith(Parameterized::class)
+class InputFieldTest(
+    private val data: InputFieldTestData<Any>,
+) {
+
+    @Test
+    fun `should set default values`() {
+        assertThat(data.initialState).all {
+            hasValue(data.initialValueEmpty)
+            hasNoError()
+            isNotValid()
+        }
+    }
+
+    @Test
+    fun `should reset error and isValid when value changed`() {
+        val initialInput = data.createInitialInput(
+            data.initialValue,
+            TestValidationError,
+            true,
+        )
+
+        val result = initialInput.updateValue(data.updatedValue)
+
+        assertThat(result).all {
+            isNotSameAs(initialInput)
+            hasValue(data.updatedValue)
+            hasNoError()
+            isNotValid()
+        }
+    }
+
+    @Test
+    fun `should reset isValid when error set`() {
+        val initialInput = data.createInitialInput(
+            data.initialValue,
+            null,
+            true,
+        )
+
+        val result = initialInput.updateError(TestValidationError)
+
+        assertThat(result).all {
+            isNotSameAs(initialInput)
+            hasValue(data.initialValue)
+            hasError(TestValidationError)
+            isNotValid()
+        }
+    }
+
+    @Test
+    fun `should reset error when valid`() {
+        val initialInput = data.createInitialInput(
+            data.initialValue,
+            TestValidationError,
+            false,
+        )
+
+        val result = initialInput.updateValidity(isValid = true)
+
+        assertThat(result).all {
+            isNotSameAs(initialInput)
+            hasValue(data.initialValue)
+            hasNoError()
+            isValid()
+        }
+    }
+
+    @Test
+    fun `should not reset error when invalid`() {
+        val initialInput = data.createInitialInput(
+            data.initialValue,
+            TestValidationError,
+            false,
+        )
+
+        val result = initialInput.updateValidity(isValid = false)
+
+        assertThat(result).all {
+            isSameAs(initialInput)
+            hasValue(data.initialValue)
+            hasError(TestValidationError)
+            isNotValid()
+        }
+    }
+
+    @Test
+    fun `should change error when error changed`() {
+        val initialInput = data.createInitialInput(
+            data.initialValue,
+            TestValidationError,
+            false,
+        )
+
+        val result = initialInput.updateError(TestValidationError2)
+
+        assertThat(result).all {
+            isNotSameAs(initialInput)
+            hasValue(data.initialValue)
+            hasError(TestValidationError2)
+            isNotValid()
+        }
+    }
+
+    @Test
+    fun `should map from success ValidationResult`() {
+        val initialInput = data.createInitialInput(
+            data.initialValue,
+            TestValidationError,
+            false,
+        )
+
+        val result = initialInput.updateFromValidationResult(ValidationResult.Success)
+
+        assertThat(result).all {
+            isNotSameAs(initialInput)
+            hasValue(data.initialValue)
+            hasNoError()
+            isValid()
+        }
+    }
+
+    @Test
+    fun `should map from failure ValidationResult`() {
+        val initialInput = data.createInitialInput(
+            data.initialValue,
+            null,
+            true,
+        )
+
+        val result = initialInput.updateFromValidationResult(ValidationResult.Failure(TestValidationError))
+
+        assertThat(result).all {
+            isNotSameAs(initialInput)
+            hasValue(data.initialValue)
+            hasError(TestValidationError)
+            isNotValid()
+        }
+    }
+
+    @Test
+    fun `should decide equality on properties`() {
+        val input1 = data.createInitialInput(
+            data.initialValue,
+            data.initialError,
+            data.initialIsValid,
+        )
+        val input2 = data.createInitialInput(
+            data.initialValue,
+            data.initialError,
+            data.initialIsValid,
+        )
+
+        assertThat(input1.equals(input2)).isTrue()
+    }
+
+    @Test
+    fun `should have same hashCode`() {
+        val input1 = data.createInitialInput(
+            data.initialValue,
+            data.initialError,
+            data.initialIsValid,
+        )
+        val input2 = data.createInitialInput(
+            data.initialValue,
+            data.initialError,
+            data.initialIsValid,
+        )
+
+        assertThat(input1.hashCode()).isEqualTo(input2.hashCode())
+    }
+
+    private fun Assert<InputField<Any>>.hasValue(value: Any) {
+        prop("value") { InputField<*>::value.call(it) }.isEqualTo(value)
+    }
+
+    private fun Assert<InputField<Any>>.hasError(error: ValidationError) {
+        prop("error") { InputField<*>::error.call(it) }.isEqualTo(error)
+    }
+
+    private fun Assert<InputField<Any>>.hasNoError() {
+        prop("error") { InputField<*>::error.call(it) }.isNull()
+    }
+
+    private fun Assert<InputField<Any>>.isValid() {
+        prop("isValid") { InputField<*>::isValid.call(it) }.isTrue()
+    }
+
+    private fun Assert<InputField<Any>>.isNotValid() {
+        prop("isValid") { InputField<*>::isValid.call(it) }.isFalse()
+    }
+
+    companion object {
+        @JvmStatic
+        @Parameterized.Parameters(name = "{0}")
+        fun data(): List<InputFieldTestData<*>> = listOf(
+            InputFieldTestData(
+                name = "StringInputField",
+                createInitialInput = { value, error, isValid -> StringInputField(value, error, isValid) },
+                initialState = StringInputField(),
+                initialValue = "input",
+                initialValueEmpty = "",
+                initialError = null,
+                initialIsValid = false,
+                updatedValue = "new value",
+            ),
+            InputFieldTestData(
+                name = "NumberInputField",
+                createInitialInput = { value, error, isValid -> NumberInputField(value, error, isValid) },
+                initialState = NumberInputField(),
+                initialValue = 123L,
+                initialValueEmpty = null,
+                initialError = null,
+                initialIsValid = false,
+                updatedValue = 456L,
+            ),
+            InputFieldTestData(
+                name = "BooleanInputField",
+                createInitialInput = { value, error, isValid -> BooleanInputField(value, error, isValid) },
+                initialState = BooleanInputField(),
+                initialValue = true,
+                initialValueEmpty = null,
+                initialError = null,
+                initialIsValid = false,
+                updatedValue = false,
+            ),
+        )
+    }
+
+    private object TestValidationError : ValidationError
+    private object TestValidationError2 : ValidationError
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/CreateAccountTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/CreateAccountTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..f6a53976b79cac5e3fc68aad8e2073df8be6523a
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/CreateAccountTest.kt
@@ -0,0 +1,76 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.feature.account.setup.AccountSetupExternalContract.AccountCreator.AccountCreatorResult
+import app.k9mail.feature.account.setup.domain.entity.Account
+import app.k9mail.feature.account.setup.domain.entity.AccountOptions
+import app.k9mail.feature.account.setup.domain.entity.MailConnectionSecurity
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import com.fsck.k9.mail.AuthType
+import com.fsck.k9.mail.ServerSettings
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+class CreateAccountTest {
+
+    @Test
+    fun `should successfully create account`() = runTest {
+        var recordedAccount: Account? = null
+        val createAccount = CreateAccount(
+            accountCreator = { account ->
+                recordedAccount = account
+                AccountCreatorResult.Success(accountUuid = "uuid")
+            },
+        )
+
+        val emailAddress = "user@example.com"
+        val incomingServerSettings = ServerSettings(
+            type = "imap",
+            host = "imap.example.com",
+            port = 993,
+            connectionSecurity = MailConnectionSecurity.SSL_TLS_REQUIRED,
+            authenticationType = AuthType.PLAIN,
+            username = "user",
+            password = "password",
+            clientCertificateAlias = null,
+        )
+        val outgoingServerSettings = ServerSettings(
+            type = "smtp",
+            host = "smtp.example.com",
+            port = 465,
+            connectionSecurity = MailConnectionSecurity.SSL_TLS_REQUIRED,
+            authenticationType = AuthType.PLAIN,
+            username = "user",
+            password = "password",
+            clientCertificateAlias = null,
+        )
+        val authorizationState = "authorization state"
+        val options = AccountOptions(
+            accountName = "accountName",
+            displayName = "displayName",
+            emailSignature = null,
+            checkFrequencyInMinutes = 15,
+            messageDisplayCount = 25,
+            showNotification = true,
+        )
+
+        val result = createAccount.execute(
+            emailAddress,
+            incomingServerSettings,
+            outgoingServerSettings,
+            authorizationState,
+            options,
+        )
+
+        assertThat(result).isEqualTo("uuid")
+        assertThat(recordedAccount).isEqualTo(
+            Account(
+                emailAddress = emailAddress,
+                incomingServerSettings = incomingServerSettings,
+                outgoingServerSettings = outgoingServerSettings,
+                authorizationState = authorizationState,
+                options = options,
+            ),
+        )
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/GetAutoDiscoveryTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/GetAutoDiscoveryTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..05cd8ddc5ab8d87599aec7eb4e13c248c30b65a6
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/GetAutoDiscoveryTest.kt
@@ -0,0 +1,189 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.autodiscovery.api.AuthenticationType
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.autodiscovery.api.AutoDiscoveryService
+import app.k9mail.autodiscovery.api.ConnectionSecurity
+import app.k9mail.autodiscovery.api.ImapServerSettings
+import app.k9mail.autodiscovery.api.IncomingServerSettings
+import app.k9mail.autodiscovery.api.SmtpServerSettings
+import app.k9mail.core.common.mail.EmailAddress
+import app.k9mail.core.common.net.toHostname
+import app.k9mail.core.common.net.toPort
+import app.k9mail.core.common.oauth.OAuthConfiguration
+import app.k9mail.core.common.oauth.OAuthConfigurationProvider
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.isInstanceOf
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+class GetAutoDiscoveryTest {
+
+    @Test
+    fun `should return a valid result`() = runTest {
+        val useCase = GetAutoDiscovery(
+            service = FakeAutoDiscoveryService(SETTINGS_WITH_PASSWORD),
+            oauthProvider = FakeOAuthConfigurationProvider(OAUTH_CONFIGURATION),
+        )
+
+        val result = useCase.execute("user@example.com")
+
+        assertThat(result)
+            .isInstanceOf<AutoDiscoveryResult.Settings>()
+            .isEqualTo(SETTINGS_WITH_PASSWORD)
+    }
+
+    @Test
+    fun `should return NoUsableSettingsFound result`() = runTest {
+        val useCase = GetAutoDiscovery(
+            service = FakeAutoDiscoveryService(AutoDiscoveryResult.NoUsableSettingsFound),
+            oauthProvider = FakeOAuthConfigurationProvider(),
+        )
+
+        val result = useCase.execute("user@example.com")
+
+        assertThat(result)
+            .isInstanceOf<AutoDiscoveryResult.NoUsableSettingsFound>()
+    }
+
+    @Test
+    fun `should return NoUsableSettingsFound result when server settings not supported`() = runTest {
+        val useCase = GetAutoDiscovery(
+            service = FakeAutoDiscoveryService(SETTINGS_WITH_UNSUPPORTED_SERVER),
+            oauthProvider = FakeOAuthConfigurationProvider(),
+        )
+
+        val result = useCase.execute("user@example.com")
+
+        assertThat(result)
+            .isInstanceOf<AutoDiscoveryResult.NoUsableSettingsFound>()
+    }
+
+    @Test
+    fun `should return UnexpectedException result`() = runTest {
+        val autoDiscoveryResult = AutoDiscoveryResult.UnexpectedException(Exception("unexpected exception"))
+        val useCase = GetAutoDiscovery(
+            service = FakeAutoDiscoveryService(autoDiscoveryResult),
+            oauthProvider = FakeOAuthConfigurationProvider(),
+        )
+
+        val result = useCase.execute("user@example.com")
+
+        assertThat(result)
+            .isInstanceOf<AutoDiscoveryResult.UnexpectedException>()
+            .isEqualTo(autoDiscoveryResult)
+    }
+
+    @Test
+    fun `should check for oauth support and return when supported`() = runTest {
+        val useCase = GetAutoDiscovery(
+            service = FakeAutoDiscoveryService(SETTINGS_WITH_OAUTH),
+            oauthProvider = FakeOAuthConfigurationProvider(OAUTH_CONFIGURATION),
+        )
+
+        val result = useCase.execute("user@example.com")
+
+        assertThat(result)
+            .isInstanceOf<AutoDiscoveryResult.Settings>()
+            .isEqualTo(SETTINGS_WITH_OAUTH)
+    }
+
+    @Test
+    fun `should check for OAuth support and drop OAuth when not supported`() = runTest {
+        val useCase = GetAutoDiscovery(
+            service = FakeAutoDiscoveryService(SETTINGS_WITH_OAUTH),
+            oauthProvider = FakeOAuthConfigurationProvider(),
+        )
+
+        val result = useCase.execute("user@example.com")
+
+        assertThat(result)
+            .isInstanceOf<AutoDiscoveryResult.Settings>()
+            .isEqualTo(
+                SETTINGS_WITH_OAUTH.copy(
+                    incomingServerSettings = (SETTINGS_WITH_OAUTH.incomingServerSettings as ImapServerSettings).copy(
+                        authenticationTypes = listOf(AuthenticationType.PasswordCleartext),
+                    ),
+                    outgoingServerSettings = (SETTINGS_WITH_OAUTH.outgoingServerSettings as SmtpServerSettings).copy(
+                        authenticationTypes = listOf(AuthenticationType.PasswordCleartext),
+                    ),
+                ),
+            )
+    }
+
+    private class FakeAutoDiscoveryService(
+        private val answer: AutoDiscoveryResult = AutoDiscoveryResult.NoUsableSettingsFound,
+    ) : AutoDiscoveryService {
+        override suspend fun discover(email: EmailAddress): AutoDiscoveryResult = answer
+    }
+
+    private class FakeOAuthConfigurationProvider(
+        private val answer: OAuthConfiguration? = null,
+    ) : OAuthConfigurationProvider {
+        override fun getConfiguration(hostname: String): OAuthConfiguration? = answer
+    }
+
+    private class UnsupportedServerSettings : IncomingServerSettings
+
+    private companion object {
+        private val SETTINGS_WITH_OAUTH = AutoDiscoveryResult.Settings(
+            incomingServerSettings = ImapServerSettings(
+                hostname = "imap.example.com".toHostname(),
+                port = 993.toPort(),
+                connectionSecurity = ConnectionSecurity.TLS,
+                authenticationTypes = listOf(AuthenticationType.OAuth2, AuthenticationType.PasswordCleartext),
+                username = "user",
+            ),
+            outgoingServerSettings = SmtpServerSettings(
+                hostname = "smtp.example.com".toHostname(),
+                port = 465.toPort(),
+                connectionSecurity = ConnectionSecurity.TLS,
+                authenticationTypes = listOf(AuthenticationType.OAuth2, AuthenticationType.PasswordCleartext),
+                username = "user",
+            ),
+            isTrusted = true,
+            source = "source",
+        )
+
+        private val SETTINGS_WITH_UNSUPPORTED_SERVER = AutoDiscoveryResult.Settings(
+            incomingServerSettings = UnsupportedServerSettings(),
+            outgoingServerSettings = SmtpServerSettings(
+                hostname = "smtp.example.com".toHostname(),
+                port = 465.toPort(),
+                connectionSecurity = ConnectionSecurity.TLS,
+                authenticationTypes = listOf(AuthenticationType.OAuth2),
+                username = "user",
+            ),
+            isTrusted = true,
+            source = "source",
+        )
+
+        private val SETTINGS_WITH_PASSWORD = AutoDiscoveryResult.Settings(
+            incomingServerSettings = ImapServerSettings(
+                hostname = "imap.example.com".toHostname(),
+                port = 993.toPort(),
+                connectionSecurity = ConnectionSecurity.TLS,
+                authenticationTypes = listOf(AuthenticationType.PasswordCleartext),
+                username = "user",
+            ),
+            outgoingServerSettings = SmtpServerSettings(
+                hostname = "smtp.example.com".toHostname(),
+                port = 465.toPort(),
+                connectionSecurity = ConnectionSecurity.TLS,
+                authenticationTypes = listOf(AuthenticationType.PasswordCleartext),
+                username = "user",
+            ),
+            isTrusted = true,
+            source = "source",
+        )
+
+        private val OAUTH_CONFIGURATION = OAuthConfiguration(
+            clientId = "clientId",
+            scopes = listOf("scopes"),
+            authorizationEndpoint = "authorizationEndpoint",
+            tokenEndpoint = "tokenEndpoint",
+            redirectUri = "redirectUri",
+        )
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateAccountNameTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateAccountNameTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..987669b4d24775a98fc3f176434b2b8eb54855f4
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateAccountNameTest.kt
@@ -0,0 +1,36 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.usecase.ValidateAccountName.ValidateAccountNameError
+import assertk.assertThat
+import assertk.assertions.isInstanceOf
+import assertk.assertions.prop
+import org.junit.Test
+
+class ValidateAccountNameTest {
+
+    private val testSubject = ValidateAccountName()
+
+    @Test
+    fun `should succeed when account name is set`() {
+        val result = testSubject.execute("account name")
+
+        assertThat(result).isInstanceOf<ValidationResult.Success>()
+    }
+
+    @Test
+    fun `should succeed when account name is empty`() {
+        val result = testSubject.execute("")
+
+        assertThat(result).isInstanceOf<ValidationResult.Success>()
+    }
+
+    @Test
+    fun `should fail when account name is blank`() {
+        val result = testSubject.execute(" ")
+
+        assertThat(result).isInstanceOf<ValidationResult.Failure>()
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf<ValidateAccountNameError.BlankAccountName>()
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateConfigurationApprovalTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateConfigurationApprovalTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..f0b325b2b4b2745e7c06e3d0e263cd85c2a13aa9
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateConfigurationApprovalTest.kt
@@ -0,0 +1,76 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import assertk.assertThat
+import assertk.assertions.isInstanceOf
+import assertk.assertions.prop
+import org.junit.Test
+
+class ValidateConfigurationApprovalTest {
+
+    private val testSubject = ValidateConfigurationApproval()
+
+    @Test
+    fun `should succeed when auto discovery is approved and trusted`() {
+        val result = testSubject.execute(isApproved = true, isAutoDiscoveryTrusted = true)
+
+        assertThat(result).isInstanceOf<ValidationResult.Success>()
+    }
+
+    @Test
+    fun `should succeed when auto discovery not approved but is trusted`() {
+        val result = testSubject.execute(isApproved = false, isAutoDiscoveryTrusted = true)
+
+        assertThat(result).isInstanceOf<ValidationResult.Success>()
+    }
+
+    @Test
+    fun `should succeed when auto discovery is approved but not trusted`() {
+        val result = testSubject.execute(isApproved = true, isAutoDiscoveryTrusted = false)
+
+        assertThat(result).isInstanceOf<ValidationResult.Success>()
+    }
+
+    @Test
+    fun `should fail when auto discovery is not approved and not trusted`() {
+        val result = testSubject.execute(isApproved = false, isAutoDiscoveryTrusted = false)
+
+        assertThat(result).isInstanceOf<ValidationResult.Failure>()
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf<ValidateConfigurationApproval.ValidateConfigurationApprovalError.ApprovalRequired>()
+    }
+
+    @Test
+    fun `should succeed when auto discovery isApproved null and is trusted`() {
+        val result = testSubject.execute(isApproved = null, isAutoDiscoveryTrusted = true)
+
+        assertThat(result).isInstanceOf<ValidationResult.Success>()
+    }
+
+    @Test
+    fun `should fail when auto discovery is isApproved null and is not trusted`() {
+        val result = testSubject.execute(isApproved = null, isAutoDiscoveryTrusted = false)
+
+        assertThat(result).isInstanceOf<ValidationResult.Failure>()
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf<ValidateConfigurationApproval.ValidateConfigurationApprovalError.ApprovalRequired>()
+    }
+
+    @Test
+    fun `should fail when auto discovery is approved and trusted is null`() {
+        val result = testSubject.execute(isApproved = false, isAutoDiscoveryTrusted = null)
+
+        assertThat(result).isInstanceOf<ValidationResult.Failure>()
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf<ValidateConfigurationApproval.ValidateConfigurationApprovalError.ApprovalRequired>()
+    }
+
+    @Test
+    fun `should fail when auto discovery is not approved and trusted is null`() {
+        val result = testSubject.execute(isApproved = false, isAutoDiscoveryTrusted = null)
+
+        assertThat(result).isInstanceOf<ValidationResult.Failure>()
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf<ValidateConfigurationApproval.ValidateConfigurationApprovalError.ApprovalRequired>()
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateDisplayNameTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateDisplayNameTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..05615e3c964945e4584d11574ee8f44f2897ff6e
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateDisplayNameTest.kt
@@ -0,0 +1,38 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.usecase.ValidateDisplayName.ValidateDisplayNameError
+import assertk.assertThat
+import assertk.assertions.isInstanceOf
+import assertk.assertions.prop
+import org.junit.Test
+
+class ValidateDisplayNameTest {
+
+    private val testSubject = ValidateDisplayName()
+
+    @Test
+    fun `should succeed when display name is set`() {
+        val result = testSubject.execute("display name")
+
+        assertThat(result).isInstanceOf<ValidationResult.Success>()
+    }
+
+    @Test
+    fun `should fail when display name is empty`() {
+        val result = testSubject.execute("")
+
+        assertThat(result).isInstanceOf<ValidationResult.Failure>()
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf<ValidateDisplayNameError.EmptyDisplayName>()
+    }
+
+    @Test
+    fun `should fail when display name is blank`() {
+        val result = testSubject.execute(" ")
+
+        assertThat(result).isInstanceOf<ValidationResult.Failure>()
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf<ValidateDisplayNameError.EmptyDisplayName>()
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateEmailAddressTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateEmailAddressTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c00d35ed7015ad1db4fd2ce5d9b3080e72928234
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateEmailAddressTest.kt
@@ -0,0 +1,38 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.usecase.ValidateEmailAddress.ValidateEmailAddressError
+import assertk.assertThat
+import assertk.assertions.isInstanceOf
+import assertk.assertions.prop
+import org.junit.Test
+
+class ValidateEmailAddressTest {
+
+    private val testSubject = ValidateEmailAddress()
+
+    @Test
+    fun `should succeed when email address is valid`() {
+        val result = testSubject.execute("test@example.com")
+
+        assertThat(result).isInstanceOf<ValidationResult.Success>()
+    }
+
+    @Test
+    fun `should fail when email address is blank`() {
+        val result = testSubject.execute(" ")
+
+        assertThat(result).isInstanceOf<ValidationResult.Failure>()
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf<ValidateEmailAddressError.EmptyEmailAddress>()
+    }
+
+    @Test
+    fun `should fail when email address is invalid`() {
+        val result = testSubject.execute("test")
+
+        assertThat(result).isInstanceOf<ValidationResult.Failure>()
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf<ValidateEmailAddressError.InvalidEmailAddress>()
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateEmailSignatureTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateEmailSignatureTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..68ab27b071279eb43503f656ead723fa00dde1e8
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateEmailSignatureTest.kt
@@ -0,0 +1,36 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.usecase.ValidateEmailSignature.ValidateEmailSignatureError
+import assertk.assertThat
+import assertk.assertions.isInstanceOf
+import assertk.assertions.prop
+import org.junit.Test
+
+class ValidateEmailSignatureTest {
+
+    private val testSubject = ValidateEmailSignature()
+
+    @Test
+    fun `should succeed when email signature is set`() {
+        val result = testSubject.execute("email signature")
+
+        assertThat(result).isInstanceOf<ValidationResult.Success>()
+    }
+
+    @Test
+    fun `should succeed when email signature is empty`() {
+        val result = testSubject.execute("")
+
+        assertThat(result).isInstanceOf<ValidationResult.Success>()
+    }
+
+    @Test
+    fun `should fail when email signature is blank`() {
+        val result = testSubject.execute(" ")
+
+        assertThat(result).isInstanceOf<ValidationResult.Failure>()
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf<ValidateEmailSignatureError.BlankEmailSignature>()
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateImapPrefixTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateImapPrefixTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..02cef9f345b077007aade2307d705e5edadc3ad6
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateImapPrefixTest.kt
@@ -0,0 +1,35 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import assertk.assertThat
+import assertk.assertions.isInstanceOf
+import assertk.assertions.prop
+import org.junit.Test
+
+class ValidateImapPrefixTest {
+
+    private val testSubject = ValidateImapPrefix()
+
+    @Test
+    fun `should success when imap prefix is set`() {
+        val result = testSubject.execute("imap")
+
+        assertThat(result).isInstanceOf<ValidationResult.Success>()
+    }
+
+    @Test
+    fun `should succeed when imap prefix is empty`() {
+        val result = testSubject.execute("")
+
+        assertThat(result).isInstanceOf<ValidationResult.Success>()
+    }
+
+    @Test
+    fun `should fail when imap prefix is blank`() {
+        val result = testSubject.execute(" ")
+
+        assertThat(result).isInstanceOf<ValidationResult.Failure>()
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf<ValidateImapPrefix.ValidateImapPrefixError.BlankImapPrefix>()
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidatePasswordTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidatePasswordTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..5f6b85e10d20fc010377b1cdd53ea101c5de5aa7
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidatePasswordTest.kt
@@ -0,0 +1,37 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import assertk.assertThat
+import assertk.assertions.isInstanceOf
+import assertk.assertions.prop
+import org.junit.Test
+
+class ValidatePasswordTest {
+
+    private val testSubject = ValidatePassword()
+
+    @Test
+    fun `should succeed when password is set`() {
+        val result = testSubject.execute("password")
+
+        assertThat(result).isInstanceOf<ValidationResult.Success>()
+    }
+
+    @Test
+    fun `should fail when password is empty`() {
+        val result = testSubject.execute("")
+
+        assertThat(result).isInstanceOf<ValidationResult.Failure>()
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf<ValidatePassword.ValidatePasswordError.EmptyPassword>()
+    }
+
+    @Test
+    fun `should fail when password is blank`() {
+        val result = testSubject.execute(" ")
+
+        assertThat(result).isInstanceOf<ValidationResult.Failure>()
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf<ValidatePassword.ValidatePasswordError.EmptyPassword>()
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidatePortTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidatePortTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..ea3600dcfa27c5c0cc5b08f9922ee8759f0dab67
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidatePortTest.kt
@@ -0,0 +1,56 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.domain.usecase.ValidatePort.ValidatePortError
+import assertk.assertThat
+import assertk.assertions.isInstanceOf
+import assertk.assertions.prop
+import org.junit.Test
+
+class ValidatePortTest {
+
+    private val testSubject = ValidatePort()
+
+    @Test
+    fun `should succeed when port is set`() {
+        val result = testSubject.execute(123L)
+
+        assertThat(result).isInstanceOf<ValidationResult.Success>()
+    }
+
+    @Test
+    fun `should fail when port is negative`() {
+        val result = testSubject.execute(-1L)
+
+        assertThat(result).isInstanceOf<ValidationResult.Failure>()
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf<ValidatePortError.InvalidPort>()
+    }
+
+    @Test
+    fun `should fail when port is zero`() {
+        val result = testSubject.execute(0)
+
+        assertThat(result).isInstanceOf<ValidationResult.Failure>()
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf<ValidatePortError.InvalidPort>()
+    }
+
+    @Test
+    fun `should fail when port exceeds maximum`() {
+        val result = testSubject.execute(65536L)
+
+        assertThat(result).isInstanceOf<ValidationResult.Failure>()
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf<ValidatePortError.InvalidPort>()
+    }
+
+    @Test
+    fun `should fail when port is null`() {
+        val result = testSubject.execute(null)
+
+        assertThat(result).isInstanceOf<ValidationResult.Failure>()
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf<ValidatePortError.EmptyPort>()
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateServerSettingsTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateServerSettingsTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..8fcec7ff2f08a9cfaa3f934da1e571e10bff0a23
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateServerSettingsTest.kt
@@ -0,0 +1,139 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.feature.account.setup.ui.validation.InMemoryAuthStateStorage
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import com.fsck.k9.mail.AuthType
+import com.fsck.k9.mail.ConnectionSecurity
+import com.fsck.k9.mail.ServerSettings
+import com.fsck.k9.mail.server.ServerSettingsValidationResult
+import java.io.IOException
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+class ValidateServerSettingsTest {
+    private val authStateStorage = InMemoryAuthStateStorage()
+
+    @Test
+    fun `should check with imap validator when protocol is imap`() = runTest {
+        val testSubject = ValidateServerSettings(
+            authStateStorage = authStateStorage,
+            imapValidator = { _, _ -> ServerSettingsValidationResult.Success },
+            pop3Validator = { _, _ -> ServerSettingsValidationResult.NetworkError(IOException("Failed POP3")) },
+            smtpValidator = { _, _ -> ServerSettingsValidationResult.NetworkError(IOException("Failed SMTP")) },
+        )
+
+        val result = testSubject.execute(IMAP_SERVER_SETTINGS)
+
+        assertThat(result).isEqualTo(ServerSettingsValidationResult.Success)
+    }
+
+    @Test
+    fun `should check with imap validator when protocol is imap and return failure`() = runTest {
+        val failure = ServerSettingsValidationResult.ServerError("Failed")
+        val testSubject = ValidateServerSettings(
+            authStateStorage = authStateStorage,
+            imapValidator = { _, _ -> failure },
+            pop3Validator = { _, _ -> ServerSettingsValidationResult.NetworkError(IOException("Failed POP3")) },
+            smtpValidator = { _, _ -> ServerSettingsValidationResult.NetworkError(IOException("Failed SMTP")) },
+        )
+
+        val result = testSubject.execute(IMAP_SERVER_SETTINGS)
+
+        assertThat(result).isEqualTo(failure)
+    }
+
+    @Test
+    fun `should check with pop3 validator when protocol is pop3`() = runTest {
+        val testSubject = ValidateServerSettings(
+            authStateStorage = authStateStorage,
+            imapValidator = { _, _ -> ServerSettingsValidationResult.NetworkError(IOException("Failed IMAP")) },
+            pop3Validator = { _, _ -> ServerSettingsValidationResult.Success },
+            smtpValidator = { _, _ -> ServerSettingsValidationResult.NetworkError(IOException("Failed SMTP")) },
+        )
+
+        val result = testSubject.execute(POP3_SERVER_SETTINGS)
+
+        assertThat(result).isEqualTo(ServerSettingsValidationResult.Success)
+    }
+
+    @Test
+    fun `should check with pop3 validator when protocol is pop3 and return failure`() = runTest {
+        val failure = ServerSettingsValidationResult.ServerError("Failed POP3")
+        val testSubject = ValidateServerSettings(
+            authStateStorage = authStateStorage,
+            imapValidator = { _, _ -> ServerSettingsValidationResult.NetworkError(IOException("Failed IMAP")) },
+            pop3Validator = { _, _ -> failure },
+            smtpValidator = { _, _ -> ServerSettingsValidationResult.NetworkError(IOException("Failed SMTP")) },
+        )
+
+        val result = testSubject.execute(POP3_SERVER_SETTINGS)
+
+        assertThat(result).isEqualTo(failure)
+    }
+
+    @Test
+    fun `should check with smtp validator when protocol is smtp`() = runTest {
+        val testSubject = ValidateServerSettings(
+            authStateStorage = authStateStorage,
+            imapValidator = { _, _ -> ServerSettingsValidationResult.NetworkError(IOException("Failed IMAP")) },
+            pop3Validator = { _, _ -> ServerSettingsValidationResult.NetworkError(IOException("Failed POP3")) },
+            smtpValidator = { _, _ -> ServerSettingsValidationResult.Success },
+        )
+
+        val result = testSubject.execute(SMTP_SERVER_SETTINGS)
+
+        assertThat(result).isEqualTo(ServerSettingsValidationResult.Success)
+    }
+
+    @Test
+    fun `should check with smtp validator when protocol is smtp and return failure`() = runTest {
+        val failure = ServerSettingsValidationResult.ServerError("Failed SMTP")
+        val testSubject = ValidateServerSettings(
+            authStateStorage = authStateStorage,
+            imapValidator = { _, _ -> ServerSettingsValidationResult.NetworkError(IOException("Failed IMAP")) },
+            pop3Validator = { _, _ -> ServerSettingsValidationResult.NetworkError(IOException("Failed POP3")) },
+            smtpValidator = { _, _ -> failure },
+        )
+
+        val result = testSubject.execute(SMTP_SERVER_SETTINGS)
+
+        assertThat(result).isEqualTo(failure)
+    }
+
+    private companion object {
+
+        val IMAP_SERVER_SETTINGS = ServerSettings(
+            type = "imap",
+            host = "imap.example.org",
+            port = 993,
+            connectionSecurity = ConnectionSecurity.SSL_TLS_REQUIRED,
+            authenticationType = AuthType.PLAIN,
+            username = "user",
+            password = "password",
+            clientCertificateAlias = null,
+        )
+
+        val POP3_SERVER_SETTINGS = ServerSettings(
+            type = "pop3",
+            host = "pop3.example.org",
+            port = 993,
+            connectionSecurity = ConnectionSecurity.SSL_TLS_REQUIRED,
+            authenticationType = AuthType.PLAIN,
+            username = "user",
+            password = "password",
+            clientCertificateAlias = null,
+        )
+
+        val SMTP_SERVER_SETTINGS = ServerSettings(
+            type = "smtp",
+            host = "smtp.example.org",
+            port = 993,
+            connectionSecurity = ConnectionSecurity.SSL_TLS_REQUIRED,
+            authenticationType = AuthType.PLAIN,
+            username = "user",
+            password = "password",
+            clientCertificateAlias = null,
+        )
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateServerTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateServerTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c0278d4892ea901b08842aba5ad0a8ca81840722
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateServerTest.kt
@@ -0,0 +1,37 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import assertk.assertThat
+import assertk.assertions.isInstanceOf
+import assertk.assertions.prop
+import org.junit.Test
+
+class ValidateServerTest {
+
+    private val testSubject = ValidateServer()
+
+    @Test
+    fun `should succeed when server is set`() {
+        val result = testSubject.execute("server")
+
+        assertThat(result).isInstanceOf<ValidationResult.Success>()
+    }
+
+    @Test
+    fun `should fail when server is empty`() {
+        val result = testSubject.execute("")
+
+        assertThat(result).isInstanceOf<ValidationResult.Failure>()
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf<ValidateServer.ValidateServerError.EmptyServer>()
+    }
+
+    @Test
+    fun `should fail when server is blank`() {
+        val result = testSubject.execute(" ")
+
+        assertThat(result).isInstanceOf<ValidationResult.Failure>()
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf<ValidateServer.ValidateServerError.EmptyServer>()
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateUsernameTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateUsernameTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d9a26c46783680a98f31644d99b138ab2635996b
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/domain/usecase/ValidateUsernameTest.kt
@@ -0,0 +1,37 @@
+package app.k9mail.feature.account.setup.domain.usecase
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import assertk.assertThat
+import assertk.assertions.isInstanceOf
+import assertk.assertions.prop
+import org.junit.Test
+
+class ValidateUsernameTest {
+
+    private val testSubject = ValidateUsername()
+
+    @Test
+    fun `should succeed when username is set`() {
+        val result = testSubject.execute("username")
+
+        assertThat(result).isInstanceOf<ValidationResult.Success>()
+    }
+
+    @Test
+    fun `should fail when username is empty`() {
+        val result = testSubject.execute("")
+
+        assertThat(result).isInstanceOf<ValidationResult.Failure>()
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf<ValidateUsername.ValidateUsernameError.EmptyUsername>()
+    }
+
+    @Test
+    fun `should fail when username is blank`() {
+        val result = testSubject.execute(" ")
+
+        assertThat(result).isInstanceOf<ValidationResult.Failure>()
+            .prop(ValidationResult.Failure::error)
+            .isInstanceOf<ValidateUsername.ValidateUsernameError.EmptyUsername>()
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupScreenKtTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupScreenKtTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..2bcbef2fed7ece622cefbc3e26345c20f78de6cc
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupScreenKtTest.kt
@@ -0,0 +1,93 @@
+package app.k9mail.feature.account.setup.ui
+
+import app.k9mail.core.ui.compose.testing.ComposeTest
+import app.k9mail.core.ui.compose.testing.onNodeWithTag
+import app.k9mail.core.ui.compose.testing.setContent
+import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.Effect
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.SetupStep
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.State
+import app.k9mail.feature.account.setup.ui.autodiscovery.FakeAccountAutoDiscoveryViewModel
+import app.k9mail.feature.account.setup.ui.incoming.FakeAccountIncomingConfigViewModel
+import app.k9mail.feature.account.setup.ui.options.FakeAccountOptionsViewModel
+import app.k9mail.feature.account.setup.ui.outgoing.FakeAccountOutgoingConfigViewModel
+import app.k9mail.feature.account.setup.ui.validation.FakeAccountValidationViewModel
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+class AccountSetupScreenKtTest : ComposeTest() {
+
+    @Test
+    fun `should display correct screen for every setup step`() = runTest {
+        val viewModel = FakeAccountSetupViewModel()
+
+        setContent {
+            ThunderbirdTheme {
+                AccountSetupScreen(
+                    onFinish = { },
+                    onBack = { },
+                    viewModel = viewModel,
+                    autoDiscoveryViewModel = FakeAccountAutoDiscoveryViewModel(),
+                    incomingViewModel = FakeAccountIncomingConfigViewModel(),
+                    incomingValidationViewModel = FakeAccountValidationViewModel(),
+                    outgoingViewModel = FakeAccountOutgoingConfigViewModel(),
+                    outgoingValidationViewModel = FakeAccountValidationViewModel(),
+                    optionsViewModel = FakeAccountOptionsViewModel(),
+                )
+            }
+        }
+
+        for (step in SetupStep.values()) {
+            viewModel.state { it.copy(setupStep = step) }
+            onNodeWithTag(getTagForStep(step)).assertExists()
+        }
+    }
+
+    @Test
+    fun `should delegate navigation effects`() = runTest {
+        val initialState = State()
+        val viewModel = FakeAccountSetupViewModel(initialState = initialState)
+        var onFinishCounter = 0
+        var onBackCounter = 0
+
+        setContent {
+            ThunderbirdTheme {
+                AccountSetupScreen(
+                    onFinish = { onFinishCounter++ },
+                    onBack = { onBackCounter++ },
+                    viewModel = viewModel,
+                    autoDiscoveryViewModel = FakeAccountAutoDiscoveryViewModel(),
+                    incomingViewModel = FakeAccountIncomingConfigViewModel(),
+                    incomingValidationViewModel = FakeAccountValidationViewModel(),
+                    outgoingViewModel = FakeAccountOutgoingConfigViewModel(),
+                    outgoingValidationViewModel = FakeAccountValidationViewModel(),
+                    optionsViewModel = FakeAccountOptionsViewModel(),
+                )
+            }
+        }
+
+        assertThat(onFinishCounter).isEqualTo(0)
+        assertThat(onBackCounter).isEqualTo(0)
+
+        viewModel.effect(Effect.NavigateNext("accountUuid"))
+
+        assertThat(onFinishCounter).isEqualTo(1)
+        assertThat(onBackCounter).isEqualTo(0)
+
+        viewModel.effect(Effect.NavigateBack)
+
+        assertThat(onFinishCounter).isEqualTo(1)
+        assertThat(onBackCounter).isEqualTo(1)
+    }
+
+    private fun getTagForStep(step: SetupStep): String = when (step) {
+        SetupStep.AUTO_CONFIG -> "AccountAutoDiscoveryContent"
+        SetupStep.INCOMING_CONFIG -> "AccountIncomingConfigContent"
+        SetupStep.INCOMING_VALIDATION -> "AccountValidationContent"
+        SetupStep.OUTGOING_CONFIG -> "AccountOutgoingConfigContent"
+        SetupStep.OUTGOING_VALIDATION -> "AccountValidationContent"
+        SetupStep.OPTIONS -> "AccountOptionsContent"
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupStateTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupStateTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c1763c34c6166c417d271719d73bac2b75299457
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupStateTest.kt
@@ -0,0 +1,20 @@
+package app.k9mail.feature.account.setup.ui
+
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.State
+import assertk.all
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.prop
+import org.junit.Test
+
+class AccountSetupStateTest {
+
+    @Test
+    fun `should set default values`() {
+        val state = State()
+
+        assertThat(state).all {
+            prop(State::setupStep).isEqualTo(AccountSetupContract.SetupStep.AUTO_CONFIG)
+        }
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupViewModelTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupViewModelTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c9937c5fef49ef8f056a6138f9bc6ce0dc877834
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/AccountSetupViewModelTest.kt
@@ -0,0 +1,305 @@
+package app.k9mail.feature.account.setup.ui
+
+import app.k9mail.core.ui.compose.testing.MainDispatcherRule
+import app.k9mail.core.ui.compose.testing.mvi.assertThatAndMviTurbinesConsumed
+import app.k9mail.core.ui.compose.testing.mvi.turbinesWithInitialStateCheck
+import app.k9mail.feature.account.setup.data.InMemoryAccountSetupStateRepository
+import app.k9mail.feature.account.setup.domain.entity.AccountOptions
+import app.k9mail.feature.account.setup.domain.entity.AccountSetupState
+import app.k9mail.feature.account.setup.domain.entity.MailConnectionSecurity
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.Effect
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.SetupStep
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.State
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.isNull
+import assertk.assertions.prop
+import com.fsck.k9.mail.AuthType
+import com.fsck.k9.mail.ServerSettings
+import kotlinx.coroutines.test.runTest
+import org.junit.Rule
+import org.junit.Test
+
+@Suppress("LongMethod")
+class AccountSetupViewModelTest {
+
+    @get:Rule
+    val mainDispatcherRule = MainDispatcherRule()
+
+    @Test
+    fun `should forward step state on next event`() = runTest {
+        var createAccountEmailAddress: String? = null
+        var createAccountIncomingServerSettings: ServerSettings? = null
+        var createAccountOutgoingServerSettings: ServerSettings? = null
+        var createAccountAuthorizationState: String? = null
+        var createAccountOptions: AccountOptions? = null
+        val accountSetupStateRepository = InMemoryAccountSetupStateRepository()
+        val viewModel = AccountSetupViewModel(
+            createAccount = { emailAddress, incomingServerSettings, outgoingServerSettings, authState, options ->
+                createAccountEmailAddress = emailAddress
+                createAccountIncomingServerSettings = incomingServerSettings
+                createAccountOutgoingServerSettings = outgoingServerSettings
+                createAccountAuthorizationState = authState
+                createAccountOptions = options
+
+                "accountUuid"
+            },
+            accountSetupStateRepository = accountSetupStateRepository,
+        )
+        val turbines = turbinesWithInitialStateCheck(viewModel, State(setupStep = SetupStep.AUTO_CONFIG))
+
+        viewModel.event(
+            AccountSetupContract.Event.OnAutoDiscoveryFinished(
+                isAutomaticConfig = false,
+            ),
+        )
+
+        val expectedAccountSetupState = AccountSetupState(
+            emailAddress = "test@domain.example",
+            incomingServerSettings = ServerSettings(
+                type = "imap",
+                host = INCOMING_SERVER_NAME,
+                port = INCOMING_SERVER_PORT,
+                connectionSecurity = MailConnectionSecurity.SSL_TLS_REQUIRED,
+                authenticationType = AuthType.CRAM_MD5,
+                username = USERNAME,
+                password = PASSWORD,
+                clientCertificateAlias = null,
+                extra = emptyMap(),
+            ),
+            outgoingServerSettings = ServerSettings(
+                type = "smtp",
+                host = OUTGOING_SERVER_NAME,
+                port = OUTGOING_SERVER_PORT,
+                connectionSecurity = MailConnectionSecurity.SSL_TLS_REQUIRED,
+                authenticationType = AuthType.CRAM_MD5,
+                username = USERNAME,
+                password = PASSWORD,
+                clientCertificateAlias = null,
+                extra = emptyMap(),
+            ),
+            authorizationState = null,
+            options = AccountOptions(
+                accountName = "account name",
+                displayName = "display name",
+                emailSignature = "signature",
+                checkFrequencyInMinutes = 15,
+                messageDisplayCount = 25,
+                showNotification = true,
+            ),
+        )
+
+        assertThatAndMviTurbinesConsumed(
+            actual = turbines.stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            prop(State::setupStep).isEqualTo(SetupStep.INCOMING_CONFIG)
+        }
+
+        viewModel.event(AccountSetupContract.Event.OnNext)
+
+        assertThatAndMviTurbinesConsumed(
+            actual = turbines.stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            prop(State::setupStep).isEqualTo(SetupStep.INCOMING_VALIDATION)
+        }
+
+        viewModel.event(AccountSetupContract.Event.OnNext)
+
+        assertThatAndMviTurbinesConsumed(
+            actual = turbines.stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            prop(State::setupStep).isEqualTo(SetupStep.OUTGOING_CONFIG)
+        }
+
+        viewModel.event(AccountSetupContract.Event.OnNext)
+
+        assertThatAndMviTurbinesConsumed(
+            actual = turbines.stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            prop(State::setupStep).isEqualTo(SetupStep.OUTGOING_VALIDATION)
+        }
+
+        viewModel.event(AccountSetupContract.Event.OnNext)
+
+        assertThatAndMviTurbinesConsumed(
+            actual = turbines.stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            prop(State::setupStep).isEqualTo(SetupStep.OPTIONS)
+        }
+
+        accountSetupStateRepository.save(expectedAccountSetupState)
+
+        viewModel.event(AccountSetupContract.Event.OnNext)
+
+        assertThatAndMviTurbinesConsumed(
+            actual = turbines.effectTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(Effect.NavigateNext("accountUuid"))
+        }
+
+        assertThat(createAccountEmailAddress).isEqualTo(EMAIL_ADDRESS)
+        assertThat(createAccountIncomingServerSettings).isEqualTo(expectedAccountSetupState.incomingServerSettings)
+        assertThat(createAccountOutgoingServerSettings).isEqualTo(expectedAccountSetupState.outgoingServerSettings)
+        assertThat(createAccountAuthorizationState).isNull()
+        assertThat(createAccountOptions).isEqualTo(expectedAccountSetupState.options)
+    }
+
+    @Test
+    fun `should rewind step state on back event`() = runTest {
+        val initialState = State(setupStep = SetupStep.OPTIONS)
+        val viewModel = AccountSetupViewModel(
+            createAccount = { _, _, _, _, _ -> "accountUuid" },
+            accountSetupStateRepository = InMemoryAccountSetupStateRepository(),
+            initialState = initialState,
+        )
+        val turbines = turbinesWithInitialStateCheck(viewModel, initialState)
+
+        viewModel.event(AccountSetupContract.Event.OnBack)
+
+        assertThatAndMviTurbinesConsumed(
+            actual = turbines.stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            prop(State::setupStep).isEqualTo(SetupStep.OUTGOING_CONFIG)
+        }
+
+        viewModel.event(AccountSetupContract.Event.OnBack)
+
+        assertThatAndMviTurbinesConsumed(
+            actual = turbines.stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            prop(State::setupStep).isEqualTo(SetupStep.INCOMING_CONFIG)
+        }
+
+        viewModel.event(AccountSetupContract.Event.OnBack)
+
+        assertThatAndMviTurbinesConsumed(
+            actual = turbines.stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            prop(State::setupStep).isEqualTo(SetupStep.AUTO_CONFIG)
+        }
+
+        viewModel.event(AccountSetupContract.Event.OnBack)
+
+        assertThatAndMviTurbinesConsumed(
+            actual = turbines.effectTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(Effect.NavigateBack)
+        }
+    }
+
+    @Test
+    fun `should go back from OPTIONS step on back event when isAutomaticConfig enabled`() = runTest {
+        val initialState = State(
+            setupStep = SetupStep.OPTIONS,
+            isAutomaticConfig = true,
+        )
+        val viewModel = AccountSetupViewModel(
+            createAccount = { _, _, _, _, _ -> "accountUuid" },
+            accountSetupStateRepository = InMemoryAccountSetupStateRepository(),
+            initialState = initialState,
+        )
+        val turbines = turbinesWithInitialStateCheck(viewModel, initialState)
+
+        viewModel.event(AccountSetupContract.Event.OnBack)
+
+        assertThatAndMviTurbinesConsumed(
+            actual = turbines.stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            prop(State::setupStep).isEqualTo(SetupStep.AUTO_CONFIG)
+        }
+
+        viewModel.event(AccountSetupContract.Event.OnBack)
+
+        assertThatAndMviTurbinesConsumed(
+            actual = turbines.effectTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(Effect.NavigateBack)
+        }
+    }
+
+    @Test
+    fun `should go back from OUTGOING_VALIDATION step state on back event when isAutomaticConfig enabled`() = runTest {
+        val initialState = State(
+            setupStep = SetupStep.OUTGOING_VALIDATION,
+            isAutomaticConfig = true,
+        )
+        val viewModel = AccountSetupViewModel(
+            createAccount = { _, _, _, _, _ -> "accountUuid" },
+            accountSetupStateRepository = InMemoryAccountSetupStateRepository(),
+            initialState = initialState,
+        )
+        val turbines = turbinesWithInitialStateCheck(viewModel, initialState)
+
+        viewModel.event(AccountSetupContract.Event.OnBack)
+
+        assertThatAndMviTurbinesConsumed(
+            actual = turbines.stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            prop(State::setupStep).isEqualTo(SetupStep.AUTO_CONFIG)
+        }
+
+        viewModel.event(AccountSetupContract.Event.OnBack)
+
+        assertThatAndMviTurbinesConsumed(
+            actual = turbines.effectTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(Effect.NavigateBack)
+        }
+    }
+
+    @Test
+    fun `should go back from INCOMING_VALIDATION step state on back event when isAutomaticConfig enabled`() = runTest {
+        val initialState = State(
+            setupStep = SetupStep.OUTGOING_VALIDATION,
+            isAutomaticConfig = true,
+        )
+        val viewModel = AccountSetupViewModel(
+            createAccount = { _, _, _, _, _ -> "accountUuid" },
+            accountSetupStateRepository = InMemoryAccountSetupStateRepository(),
+            initialState = initialState,
+        )
+        val turbines = turbinesWithInitialStateCheck(viewModel, initialState)
+
+        viewModel.event(AccountSetupContract.Event.OnBack)
+
+        assertThatAndMviTurbinesConsumed(
+            actual = turbines.stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            prop(State::setupStep).isEqualTo(SetupStep.AUTO_CONFIG)
+        }
+
+        viewModel.event(AccountSetupContract.Event.OnBack)
+
+        assertThatAndMviTurbinesConsumed(
+            actual = turbines.effectTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(Effect.NavigateBack)
+        }
+    }
+
+    companion object {
+        private const val EMAIL_ADDRESS = "test@domain.example"
+        private const val USERNAME = EMAIL_ADDRESS
+        private const val PASSWORD = "password"
+        private const val INCOMING_SERVER_NAME = "imap.domain.example"
+        private const val INCOMING_SERVER_PORT = 993
+        private const val OUTGOING_SERVER_NAME = "smtp.domain.example"
+        private const val OUTGOING_SERVER_PORT = 465
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/FakeAccountOAuthViewModel.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/FakeAccountOAuthViewModel.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d76087a2acf063190838e04a079aaa9bbcb870c6
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/FakeAccountOAuthViewModel.kt
@@ -0,0 +1,26 @@
+package app.k9mail.feature.account.setup.ui
+
+import app.k9mail.core.ui.compose.common.mvi.BaseViewModel
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract.Effect
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract.Event
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract.State
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract.ViewModel
+
+class FakeAccountOAuthViewModel(
+    initialState: State = State(),
+) : BaseViewModel<State, Event, Effect>(initialState), ViewModel {
+
+    val events = mutableListOf<Event>()
+
+    override fun initState(state: State) {
+        updateState { state }
+    }
+
+    override fun event(event: Event) {
+        events.add(event)
+    }
+
+    fun effect(effect: Effect) {
+        emitEffect(effect)
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/FakeAccountSetupViewModel.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/FakeAccountSetupViewModel.kt
new file mode 100644
index 0000000000000000000000000000000000000000..2f5ebf1451fefeda2dea83f5f074aacc4f3ce5e1
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/FakeAccountSetupViewModel.kt
@@ -0,0 +1,25 @@
+package app.k9mail.feature.account.setup.ui
+
+import app.k9mail.core.ui.compose.common.mvi.BaseViewModel
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.Effect
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.Event
+import app.k9mail.feature.account.setup.ui.AccountSetupContract.State
+
+internal class FakeAccountSetupViewModel(
+    initialState: State = State(),
+) : BaseViewModel<State, Event, Effect>(initialState), AccountSetupContract.ViewModel {
+
+    val events = mutableListOf<Event>()
+
+    fun state(update: (State) -> (State)) {
+        updateState { update(it) }
+    }
+
+    override fun event(event: Event) {
+        events.add(event)
+    }
+
+    fun effect(effect: Effect) {
+        emitEffect(effect)
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryScreenKtTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryScreenKtTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..e45e26f371087d540b4637144e4f9f70c081a58d
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryScreenKtTest.kt
@@ -0,0 +1,45 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery
+
+import app.k9mail.core.ui.compose.testing.ComposeTest
+import app.k9mail.core.ui.compose.testing.setContent
+import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.Effect
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.State
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+class AccountAutoDiscoveryScreenKtTest : ComposeTest() {
+
+    @Test
+    fun `should delegate navigation effects`() = runTest {
+        val initialState = State()
+        val viewModel = FakeAccountAutoDiscoveryViewModel(initialState)
+        var onNextCounter = 0
+        var onBackCounter = 0
+
+        setContent {
+            ThunderbirdTheme {
+                AccountAutoDiscoveryScreen(
+                    onNext = { onNextCounter++ },
+                    onBack = { onBackCounter++ },
+                    viewModel = viewModel,
+                )
+            }
+        }
+
+        assertThat(onNextCounter).isEqualTo(0)
+        assertThat(onBackCounter).isEqualTo(0)
+
+        viewModel.effect(Effect.NavigateNext(isAutomaticConfig = false))
+
+        assertThat(onNextCounter).isEqualTo(1)
+        assertThat(onBackCounter).isEqualTo(0)
+
+        viewModel.effect(Effect.NavigateBack)
+
+        assertThat(onNextCounter).isEqualTo(1)
+        assertThat(onBackCounter).isEqualTo(1)
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryStateMapperKtTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryStateMapperKtTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..6615b5019bf62858c2e2ae49d1f4855978839876
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryStateMapperKtTest.kt
@@ -0,0 +1,220 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery
+
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.autodiscovery.api.ImapServerSettings
+import app.k9mail.autodiscovery.api.SmtpServerSettings
+import app.k9mail.core.common.net.toHostname
+import app.k9mail.core.common.net.toPort
+import app.k9mail.feature.account.setup.domain.entity.AccountSetupState
+import app.k9mail.feature.account.setup.domain.entity.AuthenticationType
+import app.k9mail.feature.account.setup.domain.entity.AutoDiscoveryAuthenticationType
+import app.k9mail.feature.account.setup.domain.entity.AutoDiscoveryConnectionSecurity
+import app.k9mail.feature.account.setup.domain.entity.IncomingProtocolType
+import app.k9mail.feature.account.setup.domain.entity.toConnectionSecurity
+import app.k9mail.feature.account.setup.domain.input.NumberInputField
+import app.k9mail.feature.account.setup.domain.input.StringInputField
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import org.junit.Test
+
+class AccountAutoDiscoveryStateMapperKtTest {
+
+    @Test
+    fun `should map to empty AccountSetupState when empty`() {
+        val accountSetupState = EMPTY_STATE.toAccountSetupState()
+
+        assertThat(accountSetupState).isEqualTo(
+            AccountSetupState(
+                emailAddress = "",
+                incomingServerSettings = null,
+                outgoingServerSettings = null,
+                authorizationState = null,
+                options = null,
+            ),
+        )
+    }
+
+    @Test
+    fun `should map to default IncomingConfigState when empty`() {
+        val incomingConfigState = EMPTY_STATE.toIncomingConfigState()
+
+        assertThat(incomingConfigState).isEqualTo(AccountIncomingConfigContract.State())
+    }
+
+    @Test
+    fun `should map to IncomingConfigState when no AutoDiscovery`() {
+        val incomingConfigState = EMAIL_PASSWORD_STATE.toIncomingConfigState()
+
+        assertThat(incomingConfigState).isEqualTo(
+            AccountIncomingConfigContract.State(
+                username = StringInputField(value = EMAIL_ADDRESS),
+                password = StringInputField(value = PASSWORD),
+            ),
+        )
+    }
+
+    @Test
+    fun `should map to IncomingConfigState when AutoDiscovery`() {
+        val incomingConfigState = AUTO_DISCOVERY_STATE.toIncomingConfigState()
+
+        assertThat(incomingConfigState).isEqualTo(
+            AccountIncomingConfigContract.State(
+                protocolType = IncomingProtocolType.IMAP,
+                server = StringInputField(value = AUTO_DISCOVERY_HOSTNAME.value),
+                security = AUTO_DISCOVERY_SECURITY.toConnectionSecurity(),
+                port = NumberInputField(value = AUTO_DISCOVERY_PORT_IMAP.value.toLong()),
+                authenticationType = AuthenticationType.PasswordEncrypted,
+                username = StringInputField(value = AUTO_DISCOVERY_USERNAME),
+                password = StringInputField(value = PASSWORD),
+            ),
+        )
+    }
+
+    @Test
+    fun `should map to empty username IncomingConfigState when AutoDiscovery empty username`() {
+        val incomingConfigState = AUTO_DISCOVERY_STATE_USERNAME_EMPTY.toIncomingConfigState()
+
+        assertThat(incomingConfigState).isEqualTo(
+            AccountIncomingConfigContract.State(
+                protocolType = IncomingProtocolType.IMAP,
+                server = StringInputField(value = AUTO_DISCOVERY_HOSTNAME.value),
+                security = AUTO_DISCOVERY_SECURITY.toConnectionSecurity(),
+                port = NumberInputField(value = AUTO_DISCOVERY_PORT_IMAP.value.toLong()),
+                authenticationType = AuthenticationType.PasswordEncrypted,
+                username = StringInputField(value = ""),
+                password = StringInputField(value = PASSWORD),
+            ),
+        )
+    }
+
+    @Test
+    fun `should map to OutgoingConfigState when empty`() {
+        val outgoingConfigState = EMPTY_STATE.toOutgoingConfigState()
+
+        assertThat(outgoingConfigState).isEqualTo(AccountOutgoingConfigContract.State())
+    }
+
+    @Test
+    fun `should map to OutgoingConfigState when no AutoDiscovery`() {
+        val outgoingConfigState = EMAIL_PASSWORD_STATE.toOutgoingConfigState()
+
+        assertThat(outgoingConfigState).isEqualTo(
+            AccountOutgoingConfigContract.State(
+                username = StringInputField(value = EMAIL_ADDRESS),
+                password = StringInputField(value = PASSWORD),
+            ),
+        )
+    }
+
+    @Test
+    fun `should map to OutgoingConfigState when AutoDiscovery`() {
+        val outgoingConfigState = AUTO_DISCOVERY_STATE.toOutgoingConfigState()
+
+        assertThat(outgoingConfigState).isEqualTo(
+            AccountOutgoingConfigContract.State(
+                server = StringInputField(value = AUTO_DISCOVERY_HOSTNAME.value),
+                security = AUTO_DISCOVERY_SECURITY.toConnectionSecurity(),
+                port = NumberInputField(value = AUTO_DISCOVERY_PORT_SMTP.value.toLong()),
+                authenticationType = AuthenticationType.PasswordEncrypted,
+                username = StringInputField(value = AUTO_DISCOVERY_USERNAME),
+                password = StringInputField(value = PASSWORD),
+            ),
+        )
+    }
+
+    @Test
+    fun `should map to empty username OutgoingConfigState when AutoDiscovery empty username`() {
+        val outgoingConfigState = AUTO_DISCOVERY_STATE_USERNAME_EMPTY.toOutgoingConfigState()
+
+        assertThat(outgoingConfigState).isEqualTo(
+            AccountOutgoingConfigContract.State(
+                server = StringInputField(value = AUTO_DISCOVERY_HOSTNAME.value),
+                security = AUTO_DISCOVERY_SECURITY.toConnectionSecurity(),
+                port = NumberInputField(value = AUTO_DISCOVERY_PORT_SMTP.value.toLong()),
+                authenticationType = AuthenticationType.PasswordEncrypted,
+                username = StringInputField(value = ""),
+                password = StringInputField(value = PASSWORD),
+            ),
+        )
+    }
+
+    @Test
+    fun `should map to OptionsState when empty`() {
+        val optionsState = EMPTY_STATE.toOptionsState()
+
+        assertThat(optionsState).isEqualTo(AccountOptionsContract.State())
+    }
+
+    @Test
+    fun `should map to OptionsState when email and password set`() {
+        val optionsState = EMAIL_PASSWORD_STATE.toOptionsState()
+
+        assertThat(optionsState).isEqualTo(
+            AccountOptionsContract.State(
+                accountName = StringInputField(value = EMAIL_ADDRESS),
+            ),
+        )
+    }
+
+    private companion object {
+        const val EMAIL_ADDRESS = "test@example.com"
+        const val PASSWORD = "password"
+        const val SERVER_IMAP = "imap.example.com"
+        const val SERVER_SMTP = "smtp.example.com"
+
+        val AUTO_DISCOVERY_HOSTNAME = "incoming.example.com".toHostname()
+        val AUTO_DISCOVERY_PORT_IMAP = 143.toPort()
+        val AUTO_DISCOVERY_PORT_SMTP = 587.toPort()
+        val AUTO_DISCOVERY_SECURITY = AutoDiscoveryConnectionSecurity.StartTLS
+        val AUTO_DISCOVERY_AUTHENTICATION = AutoDiscoveryAuthenticationType.PasswordEncrypted
+        const val AUTO_DISCOVERY_USERNAME = "username"
+
+        val EMPTY_STATE = AccountAutoDiscoveryContract.State()
+
+        val EMAIL_PASSWORD_STATE = AccountAutoDiscoveryContract.State(
+            emailAddress = StringInputField(value = EMAIL_ADDRESS),
+            password = StringInputField(value = PASSWORD),
+        )
+
+        val AUTO_DISCOVERY_STATE = EMAIL_PASSWORD_STATE.copy(
+            autoDiscoverySettings = AutoDiscoveryResult.Settings(
+                incomingServerSettings = ImapServerSettings(
+                    hostname = AUTO_DISCOVERY_HOSTNAME,
+                    port = AUTO_DISCOVERY_PORT_IMAP,
+                    connectionSecurity = AUTO_DISCOVERY_SECURITY,
+                    authenticationTypes = listOf(AUTO_DISCOVERY_AUTHENTICATION),
+                    username = AUTO_DISCOVERY_USERNAME,
+                ),
+                outgoingServerSettings = SmtpServerSettings(
+                    hostname = AUTO_DISCOVERY_HOSTNAME,
+                    port = AUTO_DISCOVERY_PORT_SMTP,
+                    connectionSecurity = AUTO_DISCOVERY_SECURITY,
+                    authenticationTypes = listOf(AUTO_DISCOVERY_AUTHENTICATION),
+                    username = AUTO_DISCOVERY_USERNAME,
+                ),
+                isTrusted = true,
+                source = "test",
+            ),
+        )
+
+        val AUTO_DISCOVERY_STATE_USERNAME_EMPTY = AUTO_DISCOVERY_STATE.copy(
+            autoDiscoverySettings = AUTO_DISCOVERY_STATE.autoDiscoverySettings?.copy(
+                incomingServerSettings = (
+                    AUTO_DISCOVERY_STATE.autoDiscoverySettings
+                        ?.incomingServerSettings as ImapServerSettings
+                    ).copy(
+                    username = "",
+                ),
+                outgoingServerSettings = (
+                    AUTO_DISCOVERY_STATE.autoDiscoverySettings
+                        ?.outgoingServerSettings as SmtpServerSettings
+                    ).copy(
+                    username = "",
+                ),
+            ),
+        )
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryStateTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryStateTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..fee85038cd369f422181fdf81559323116151ccb
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryStateTest.kt
@@ -0,0 +1,29 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery
+
+import app.k9mail.feature.account.setup.domain.input.BooleanInputField
+import app.k9mail.feature.account.setup.domain.input.StringInputField
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.ConfigStep
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.State
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import org.junit.Test
+
+class AccountAutoDiscoveryStateTest {
+
+    @Test
+    fun `should set default values`() {
+        val state = State()
+
+        assertThat(state).isEqualTo(
+            State(
+                configStep = ConfigStep.EMAIL_ADDRESS,
+                emailAddress = StringInputField(),
+                password = StringInputField(),
+                autoDiscoverySettings = null,
+                configurationApproved = BooleanInputField(),
+                error = null,
+                isLoading = false,
+            ),
+        )
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryViewModelTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryViewModelTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..7099eb6dce121510980a750298efd40a1402e462
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/AccountAutoDiscoveryViewModelTest.kt
@@ -0,0 +1,448 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery
+
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.core.ui.compose.testing.MainDispatcherRule
+import app.k9mail.core.ui.compose.testing.mvi.assertThatAndMviTurbinesConsumed
+import app.k9mail.core.ui.compose.testing.mvi.eventStateTest
+import app.k9mail.core.ui.compose.testing.mvi.turbinesWithInitialStateCheck
+import app.k9mail.feature.account.setup.data.InMemoryAccountSetupStateRepository
+import app.k9mail.feature.account.setup.domain.DomainContract
+import app.k9mail.feature.account.setup.domain.entity.AccountSetupState
+import app.k9mail.feature.account.setup.domain.entity.AutoDiscoverySettingsFixture
+import app.k9mail.feature.account.setup.domain.input.BooleanInputField
+import app.k9mail.feature.account.setup.domain.input.StringInputField
+import app.k9mail.feature.account.setup.ui.FakeAccountOAuthViewModel
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.ConfigStep
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.Effect
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.Error
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.Event
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.State
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.test.runTest
+import org.junit.Rule
+import org.junit.Test
+
+class AccountAutoDiscoveryViewModelTest {
+
+    @get:Rule
+    val mainDispatcherRule = MainDispatcherRule()
+
+    @Test
+    fun `should reset state when EmailAddressChanged event is received`() = runTest {
+        val initialState = State(
+            configStep = ConfigStep.PASSWORD,
+            emailAddress = StringInputField(value = "email"),
+            password = StringInputField(value = "password"),
+        )
+        val testSubject = createTestSubject(initialState)
+
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = initialState,
+            event = Event.EmailAddressChanged("email"),
+            expectedState = State(
+                configStep = ConfigStep.EMAIL_ADDRESS,
+                emailAddress = StringInputField(value = "email"),
+                password = StringInputField(),
+            ),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when PasswordChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = createTestSubject(),
+            initialState = State(),
+            event = Event.PasswordChanged("password"),
+            expectedState = State(
+                password = StringInputField(value = "password"),
+            ),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when ConfigurationApprovalChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = createTestSubject(),
+            initialState = State(),
+            event = Event.ConfigurationApprovalChanged(true),
+            expectedState = State(
+                configurationApproved = BooleanInputField(value = true),
+            ),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state to password when OnNextClicked event is received, input valid and discovery loaded`() =
+        runTest {
+            val autoDiscoverySettings = AutoDiscoverySettingsFixture.settings
+            val initialState = State(
+                configStep = ConfigStep.EMAIL_ADDRESS,
+                emailAddress = StringInputField(value = "email"),
+            )
+            val testSubject = AccountAutoDiscoveryViewModel(
+                validator = FakeAccountAutoDiscoveryValidator(),
+                getAutoDiscovery = {
+                    delay(50)
+                    autoDiscoverySettings
+                },
+                oAuthViewModel = FakeAccountOAuthViewModel(),
+                accountSetupStateRepository = InMemoryAccountSetupStateRepository(),
+                initialState = initialState,
+            )
+            val turbines = turbinesWithInitialStateCheck(testSubject, initialState)
+
+            testSubject.event(Event.OnNextClicked)
+
+            val validatedState = initialState.copy(
+                emailAddress = StringInputField(
+                    value = "email",
+                    error = null,
+                    isValid = true,
+                ),
+            )
+            assertThat(turbines.stateTurbine.awaitItem()).isEqualTo(validatedState)
+
+            val loadingState = validatedState.copy(
+                isLoading = true,
+            )
+            assertThat(turbines.stateTurbine.awaitItem()).isEqualTo(loadingState)
+
+            val successState = validatedState.copy(
+                autoDiscoverySettings = autoDiscoverySettings,
+                configStep = ConfigStep.PASSWORD,
+                isLoading = false,
+            )
+            assertThatAndMviTurbinesConsumed(
+                actual = turbines.stateTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(successState)
+            }
+        }
+
+    @Test
+    fun `should not change state when OnNextClicked event is received, input valid but discovery failed`() =
+        runTest {
+            val initialState = State(
+                configStep = ConfigStep.EMAIL_ADDRESS,
+                emailAddress = StringInputField(value = "email"),
+            )
+            val discoveryError = Exception("discovery error")
+            val testSubject = AccountAutoDiscoveryViewModel(
+                validator = FakeAccountAutoDiscoveryValidator(),
+                getAutoDiscovery = {
+                    delay(50)
+                    AutoDiscoveryResult.UnexpectedException(discoveryError)
+                },
+                oAuthViewModel = FakeAccountOAuthViewModel(),
+                accountSetupStateRepository = InMemoryAccountSetupStateRepository(),
+                initialState = initialState,
+            )
+            val turbines = turbinesWithInitialStateCheck(testSubject, initialState)
+
+            testSubject.event(Event.OnNextClicked)
+
+            val validatedState = initialState.copy(
+                emailAddress = StringInputField(
+                    value = "email",
+                    error = null,
+                    isValid = true,
+                ),
+            )
+            assertThat(turbines.stateTurbine.awaitItem()).isEqualTo(validatedState)
+
+            val loadingState = validatedState.copy(
+                isLoading = true,
+            )
+            assertThat(turbines.stateTurbine.awaitItem()).isEqualTo(loadingState)
+
+            val failureState = validatedState.copy(
+                isLoading = false,
+                error = Error.UnknownError,
+            )
+            assertThatAndMviTurbinesConsumed(
+                actual = turbines.stateTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(failureState)
+            }
+        }
+
+    @Test
+    fun `should reset error state and change to password step when OnNextClicked event received when having error`() =
+        runTest {
+            val initialState = State(
+                configStep = ConfigStep.EMAIL_ADDRESS,
+                emailAddress = StringInputField(
+                    value = "email",
+                    isValid = true,
+                ),
+                error = Error.UnknownError,
+            )
+            val testSubject = createTestSubject(initialState)
+
+            eventStateTest(
+                viewModel = testSubject,
+                initialState = initialState,
+                event = Event.OnNextClicked,
+                expectedState = State(
+                    configStep = ConfigStep.PASSWORD,
+                    emailAddress = StringInputField(
+                        value = "email",
+                        isValid = true,
+                    ),
+                    error = null,
+                ),
+                coroutineScope = backgroundScope,
+            )
+        }
+
+    @Test
+    fun `should not change config step to password when OnNextClicked event is received and input invalid`() = runTest {
+        val initialState = State(
+            configStep = ConfigStep.EMAIL_ADDRESS,
+            emailAddress = StringInputField(value = "invalid email"),
+        )
+        val testSubject = AccountAutoDiscoveryViewModel(
+            validator = FakeAccountAutoDiscoveryValidator(
+                emailAddressAnswer = ValidationResult.Failure(TestError),
+            ),
+            getAutoDiscovery = { AutoDiscoveryResult.NoUsableSettingsFound },
+            oAuthViewModel = FakeAccountOAuthViewModel(),
+            accountSetupStateRepository = InMemoryAccountSetupStateRepository(),
+            initialState = initialState,
+        )
+
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = initialState,
+            event = Event.OnNextClicked,
+            expectedState = State(
+                configStep = ConfigStep.EMAIL_ADDRESS,
+                emailAddress = StringInputField(
+                    value = "invalid email",
+                    error = TestError,
+                    isValid = false,
+                ),
+            ),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should save state and emit NavigateNext when OnNextClicked received in password step with valid input`() =
+        runTest {
+            val initialState = State(
+                configStep = ConfigStep.PASSWORD,
+                emailAddress = StringInputField(value = "email"),
+                password = StringInputField(value = "password"),
+            )
+            val repository = InMemoryAccountSetupStateRepository()
+            val testSubject = createTestSubject(
+                initialState = initialState,
+                repository = repository,
+            )
+            val turbines = turbinesWithInitialStateCheck(testSubject, initialState)
+
+            testSubject.event(Event.OnNextClicked)
+
+            assertThat(turbines.stateTurbine.awaitItem()).isEqualTo(
+                State(
+                    configStep = ConfigStep.PASSWORD,
+                    emailAddress = StringInputField(
+                        value = "email",
+                        error = null,
+                        isValid = true,
+                    ),
+                    password = StringInputField(
+                        value = "password",
+                        error = null,
+                        isValid = true,
+                    ),
+                    configurationApproved = BooleanInputField(
+                        value = null,
+                        error = null,
+                        isValid = true,
+                    ),
+                ),
+            )
+
+            assertThatAndMviTurbinesConsumed(
+                actual = turbines.effectTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(Effect.NavigateNext(isAutomaticConfig = false))
+            }
+
+            assertThat(repository.getState()).isEqualTo(
+                AccountSetupState(
+                    emailAddress = "email",
+                    incomingServerSettings = null,
+                    outgoingServerSettings = null,
+                    authorizationState = null,
+                    options = null,
+                ),
+            )
+        }
+
+    @Test
+    fun `should not emit NavigateNext when OnNextClicked received in password step with invalid input`() =
+        runTest {
+            val initialState = State(
+                configStep = ConfigStep.PASSWORD,
+                emailAddress = StringInputField(value = "email"),
+                password = StringInputField(value = "password"),
+            )
+            val viewModel = AccountAutoDiscoveryViewModel(
+                validator = FakeAccountAutoDiscoveryValidator(
+                    passwordAnswer = ValidationResult.Failure(TestError),
+                ),
+                getAutoDiscovery = { AutoDiscoveryResult.NoUsableSettingsFound },
+                oAuthViewModel = FakeAccountOAuthViewModel(),
+                accountSetupStateRepository = InMemoryAccountSetupStateRepository(),
+                initialState = initialState,
+            )
+            val turbines = turbinesWithInitialStateCheck(viewModel, initialState)
+
+            viewModel.event(Event.OnNextClicked)
+
+            assertThatAndMviTurbinesConsumed(
+                actual = turbines.stateTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(
+                    State(
+                        configStep = ConfigStep.PASSWORD,
+                        emailAddress = StringInputField(
+                            value = "email",
+                            error = null,
+                            isValid = true,
+                        ),
+                        password = StringInputField(
+                            value = "password",
+                            error = TestError,
+                            isValid = false,
+                        ),
+                        configurationApproved = BooleanInputField(
+                            value = null,
+                            error = null,
+                            isValid = true,
+                        ),
+                    ),
+                )
+            }
+        }
+
+    @Test
+    fun `should emit NavigateBack effect when OnBackClicked event is received`() = runTest {
+        val testSubject = createTestSubject()
+        val turbines = turbinesWithInitialStateCheck(testSubject, State())
+
+        testSubject.event(Event.OnBackClicked)
+
+        assertThatAndMviTurbinesConsumed(
+            actual = turbines.effectTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(Effect.NavigateBack)
+        }
+    }
+
+    @Test
+    fun `should change config step to email address when OnBackClicked event is received in password config step`() =
+        runTest {
+            val initialState = State(
+                configStep = ConfigStep.PASSWORD,
+                emailAddress = StringInputField(value = "email"),
+                password = StringInputField(value = "password"),
+            )
+            val testSubject = createTestSubject(initialState)
+            val turbines = turbinesWithInitialStateCheck(testSubject, initialState)
+
+            testSubject.event(Event.OnBackClicked)
+
+            assertThatAndMviTurbinesConsumed(
+                actual = turbines.stateTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(
+                    State(
+                        configStep = ConfigStep.EMAIL_ADDRESS,
+                        emailAddress = StringInputField(value = "email"),
+                    ),
+                )
+            }
+        }
+
+    @Test
+    fun `should reset error state when OnBackClicked event received when having error and in email address step`() =
+        runTest {
+            val initialState = State(
+                configStep = ConfigStep.EMAIL_ADDRESS,
+                emailAddress = StringInputField(
+                    value = "email",
+                    isValid = true,
+                ),
+                error = Error.UnknownError,
+            )
+            val testSubject = createTestSubject(initialState)
+
+            eventStateTest(
+                viewModel = testSubject,
+                initialState = initialState,
+                event = Event.OnBackClicked,
+                expectedState = State(
+                    configStep = ConfigStep.EMAIL_ADDRESS,
+                    emailAddress = StringInputField(
+                        value = "email",
+                        isValid = true,
+                    ),
+                    error = null,
+                ),
+                coroutineScope = backgroundScope,
+            )
+        }
+
+    @Test
+    fun `should emit NavigateNext effect when OnEditConfigurationClicked event is received`() = runTest {
+        val testSubject = createTestSubject()
+        val turbines = turbinesWithInitialStateCheck(testSubject, State())
+
+        testSubject.event(Event.OnEditConfigurationClicked)
+
+        assertThatAndMviTurbinesConsumed(
+            actual = turbines.effectTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(Effect.NavigateNext(isAutomaticConfig = false))
+        }
+    }
+
+    private object TestError : ValidationError
+
+    private companion object {
+        fun createTestSubject(
+            initialState: State = State(),
+            repository: DomainContract.AccountSetupStateRepository = InMemoryAccountSetupStateRepository(),
+        ): AccountAutoDiscoveryViewModel {
+            return AccountAutoDiscoveryViewModel(
+                validator = FakeAccountAutoDiscoveryValidator(),
+                getAutoDiscovery = {
+                    delay(50)
+                    AutoDiscoveryResult.NoUsableSettingsFound
+                },
+                accountSetupStateRepository = repository,
+                oAuthViewModel = FakeAccountOAuthViewModel(),
+                initialState = initialState,
+            )
+        }
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/FakeAccountAutoDiscoveryValidator.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/FakeAccountAutoDiscoveryValidator.kt
new file mode 100644
index 0000000000000000000000000000000000000000..57237f562faa9b382fb65d434f9450954f1b44a5
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/FakeAccountAutoDiscoveryValidator.kt
@@ -0,0 +1,16 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+
+class FakeAccountAutoDiscoveryValidator(
+    private val emailAddressAnswer: ValidationResult = ValidationResult.Success,
+    private val passwordAnswer: ValidationResult = ValidationResult.Success,
+    private val configurationApprovalAnswer: ValidationResult = ValidationResult.Success,
+) : AccountAutoDiscoveryContract.Validator {
+    override fun validateEmailAddress(emailAddress: String): ValidationResult = emailAddressAnswer
+    override fun validatePassword(password: String): ValidationResult = passwordAnswer
+    override fun validateConfigurationApproval(
+        isApproved: Boolean?,
+        isAutoDiscoveryTrusted: Boolean?,
+    ): ValidationResult = configurationApprovalAnswer
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/FakeAccountAutoDiscoveryViewModel.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/FakeAccountAutoDiscoveryViewModel.kt
new file mode 100644
index 0000000000000000000000000000000000000000..a33c8373bd671d609089f9ad199689b526f18c98
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/autodiscovery/FakeAccountAutoDiscoveryViewModel.kt
@@ -0,0 +1,29 @@
+package app.k9mail.feature.account.setup.ui.autodiscovery
+
+import app.k9mail.core.ui.compose.common.mvi.BaseViewModel
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract
+import app.k9mail.feature.account.setup.ui.FakeAccountOAuthViewModel
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.Effect
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.Event
+import app.k9mail.feature.account.setup.ui.autodiscovery.AccountAutoDiscoveryContract.State
+
+class FakeAccountAutoDiscoveryViewModel(
+    initialState: State = State(),
+) : BaseViewModel<State, Event, Effect>(initialState), AccountAutoDiscoveryContract.ViewModel {
+
+    val events = mutableListOf<Event>()
+
+    override val oAuthViewModel: AccountOAuthContract.ViewModel = FakeAccountOAuthViewModel()
+
+    override fun initState(state: State) {
+        updateState { state }
+    }
+
+    override fun event(event: Event) {
+        events.add(event)
+    }
+
+    fun effect(effect: Effect) {
+        emitEffect(effect)
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigScreenKtTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigScreenKtTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..4525f2534802243e9f9ae3d5921c71c219bfa4ac
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigScreenKtTest.kt
@@ -0,0 +1,42 @@
+package app.k9mail.feature.account.setup.ui.incoming
+
+import app.k9mail.core.ui.compose.testing.ComposeTest
+import app.k9mail.core.ui.compose.testing.setContent
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.Effect
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.State
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+class AccountIncomingConfigScreenKtTest : ComposeTest() {
+
+    @Test
+    fun `should delegate navigation effects`() = runTest {
+        val initialState = State()
+        val viewModel = FakeAccountIncomingConfigViewModel(initialState)
+        var onNextCounter = 0
+        var onBackCounter = 0
+
+        setContent {
+            AccountIncomingConfigScreen(
+                onNext = { onNextCounter++ },
+                onBack = { onBackCounter++ },
+                viewModel = viewModel,
+            )
+        }
+
+        assertThat(onNextCounter).isEqualTo(0)
+        assertThat(onBackCounter).isEqualTo(0)
+
+        viewModel.effect(Effect.NavigateNext)
+
+        assertThat(onNextCounter).isEqualTo(1)
+        assertThat(onBackCounter).isEqualTo(0)
+
+        viewModel.effect(Effect.NavigateBack)
+
+        assertThat(onNextCounter).isEqualTo(1)
+        assertThat(onBackCounter).isEqualTo(1)
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigStateMapperKtTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigStateMapperKtTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..fa6350949668dc7dcdb8015903a9c602f81a88b2
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigStateMapperKtTest.kt
@@ -0,0 +1,90 @@
+package app.k9mail.feature.account.setup.ui.incoming
+
+import app.k9mail.feature.account.setup.domain.entity.AuthenticationType
+import app.k9mail.feature.account.setup.domain.entity.ConnectionSecurity
+import app.k9mail.feature.account.setup.domain.entity.IncomingProtocolType
+import app.k9mail.feature.account.setup.domain.entity.MailConnectionSecurity
+import app.k9mail.feature.account.setup.domain.input.NumberInputField
+import app.k9mail.feature.account.setup.domain.input.StringInputField
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.State
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import com.fsck.k9.mail.AuthType
+import com.fsck.k9.mail.ServerSettings
+import com.fsck.k9.mail.store.imap.ImapStoreSettings
+import org.junit.Test
+
+class AccountIncomingConfigStateMapperKtTest {
+
+    @Test
+    fun `should map to IMAP server settings`() {
+        val incomingState = State(
+            protocolType = IncomingProtocolType.IMAP,
+            server = StringInputField(value = "imap.example.org"),
+            port = NumberInputField(value = 993),
+            security = ConnectionSecurity.TLS,
+            authenticationType = AuthenticationType.PasswordCleartext,
+            username = StringInputField(value = "user"),
+            password = StringInputField(value = "password"),
+            clientCertificateAlias = null,
+            imapAutodetectNamespaceEnabled = true,
+            imapPrefix = StringInputField(value = "prefix"),
+            imapUseCompression = true,
+            imapSendClientId = true,
+        )
+
+        val result = incomingState.toServerSettings()
+
+        assertThat(result).isEqualTo(
+            ServerSettings(
+                type = "imap",
+                host = "imap.example.org",
+                port = 993,
+                connectionSecurity = MailConnectionSecurity.SSL_TLS_REQUIRED,
+                authenticationType = AuthType.PLAIN,
+                username = "user",
+                password = "password",
+                clientCertificateAlias = null,
+                extra = ImapStoreSettings.createExtra(
+                    autoDetectNamespace = true,
+                    pathPrefix = null,
+                    useCompression = true,
+                    sendClientId = true,
+                ),
+            ),
+        )
+    }
+
+    @Test
+    fun `should map to POP3 server settings`() {
+        val incomingState = State(
+            protocolType = IncomingProtocolType.POP3,
+            server = StringInputField(value = "pop3.domain.example"),
+            port = NumberInputField(value = 995),
+            security = ConnectionSecurity.TLS,
+            authenticationType = AuthenticationType.PasswordCleartext,
+            username = StringInputField(value = "user"),
+            password = StringInputField(value = "password"),
+            clientCertificateAlias = null,
+            imapAutodetectNamespaceEnabled = true,
+            imapPrefix = StringInputField(value = "prefix"),
+            imapUseCompression = true,
+            imapSendClientId = true,
+        )
+
+        val result = incomingState.toServerSettings()
+
+        assertThat(result).isEqualTo(
+            ServerSettings(
+                type = "pop3",
+                host = "pop3.domain.example",
+                port = 995,
+                connectionSecurity = MailConnectionSecurity.SSL_TLS_REQUIRED,
+                authenticationType = AuthType.PLAIN,
+                username = "user",
+                password = "password",
+                clientCertificateAlias = null,
+            ),
+        )
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigStateTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigStateTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..b1bdf26301207b2a36e9cd282f247963b7282df3
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigStateTest.kt
@@ -0,0 +1,36 @@
+package app.k9mail.feature.account.setup.ui.incoming
+
+import app.k9mail.feature.account.setup.domain.entity.AuthenticationType
+import app.k9mail.feature.account.setup.domain.entity.ConnectionSecurity
+import app.k9mail.feature.account.setup.domain.entity.IncomingProtocolType
+import app.k9mail.feature.account.setup.domain.entity.toImapDefaultPort
+import app.k9mail.feature.account.setup.domain.input.NumberInputField
+import app.k9mail.feature.account.setup.domain.input.StringInputField
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.State
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import org.junit.Test
+
+class AccountIncomingConfigStateTest {
+
+    @Test
+    fun `should set default values`() {
+        val state = State()
+
+        assertThat(state).isEqualTo(
+            State(
+                protocolType = IncomingProtocolType.IMAP,
+                server = StringInputField(),
+                security = ConnectionSecurity.DEFAULT,
+                port = NumberInputField(value = ConnectionSecurity.DEFAULT.toImapDefaultPort()),
+                authenticationType = AuthenticationType.PasswordCleartext,
+                username = StringInputField(),
+                password = StringInputField(),
+                clientCertificateAlias = null,
+                imapAutodetectNamespaceEnabled = true,
+                imapUseCompression = true,
+                imapSendClientId = true,
+            ),
+        )
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigViewModelTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigViewModelTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..cd0b35cdabb4d2ca351c8113ae7aa5cb5fea2932
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/incoming/AccountIncomingConfigViewModelTest.kt
@@ -0,0 +1,445 @@
+package app.k9mail.feature.account.setup.ui.incoming
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.core.ui.compose.testing.MainDispatcherRule
+import app.k9mail.core.ui.compose.testing.mvi.assertThatAndMviTurbinesConsumed
+import app.k9mail.core.ui.compose.testing.mvi.eventStateTest
+import app.k9mail.core.ui.compose.testing.mvi.turbines
+import app.k9mail.core.ui.compose.testing.mvi.turbinesWithInitialStateCheck
+import app.k9mail.feature.account.setup.data.InMemoryAccountSetupStateRepository
+import app.k9mail.feature.account.setup.domain.DomainContract
+import app.k9mail.feature.account.setup.domain.entity.AccountSetupState
+import app.k9mail.feature.account.setup.domain.entity.AuthenticationType
+import app.k9mail.feature.account.setup.domain.entity.ConnectionSecurity
+import app.k9mail.feature.account.setup.domain.entity.IncomingProtocolType
+import app.k9mail.feature.account.setup.domain.entity.MailConnectionSecurity
+import app.k9mail.feature.account.setup.domain.entity.toImapDefaultPort
+import app.k9mail.feature.account.setup.domain.entity.toPop3DefaultPort
+import app.k9mail.feature.account.setup.domain.input.NumberInputField
+import app.k9mail.feature.account.setup.domain.input.StringInputField
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.Effect
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.Event
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.State
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import com.fsck.k9.mail.AuthType
+import com.fsck.k9.mail.ServerSettings
+import kotlinx.coroutines.test.runTest
+import org.junit.Rule
+import org.junit.Test
+
+class AccountIncomingConfigViewModelTest {
+
+    @get:Rule
+    val mainDispatcherRule = MainDispatcherRule()
+
+    @Test
+    fun `should take initial state from repository when no initial state is provided`() = runTest {
+        val accountSetupState = AccountSetupState(
+            emailAddress = "test@example.com",
+            incomingServerSettings = ServerSettings(
+                "imap",
+                "imap.example.com",
+                123,
+                MailConnectionSecurity.SSL_TLS_REQUIRED,
+                AuthType.PLAIN,
+                "username",
+                "password",
+                clientCertificateAlias = null,
+                extra = emptyMap(),
+            ),
+        )
+        val testSubject = createTestSubject(
+            initialState = null,
+            repository = InMemoryAccountSetupStateRepository(accountSetupState),
+        )
+        val turbines = turbines(testSubject)
+
+        assertThatAndMviTurbinesConsumed(
+            actual = turbines.awaitStateItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(
+                State(
+                    protocolType = IncomingProtocolType.IMAP,
+                    server = StringInputField(value = "imap.example.com"),
+                    security = ConnectionSecurity.TLS,
+                    port = NumberInputField(value = 123L),
+                    authenticationType = AuthenticationType.PasswordCleartext,
+                    username = StringInputField(value = "username"),
+                    password = StringInputField(value = "password"),
+                ),
+            )
+        }
+    }
+
+    @Test
+    fun `should load account setup state when LoadAccountSetupState event is received`() = runTest {
+        val accountSetupState = AccountSetupState(
+            emailAddress = "test@example.com",
+            incomingServerSettings = ServerSettings(
+                "imap",
+                "imap.example.com",
+                123,
+                MailConnectionSecurity.SSL_TLS_REQUIRED,
+                AuthType.PLAIN,
+                "username",
+                "password",
+                clientCertificateAlias = null,
+                extra = emptyMap(),
+            ),
+        )
+        val repository = InMemoryAccountSetupStateRepository(AccountSetupState())
+        val testSubject = createTestSubject(
+            initialState = null,
+            repository = repository,
+        )
+        val turbines = turbinesWithInitialStateCheck(testSubject, State())
+
+        repository.save(accountSetupState)
+
+        testSubject.event(Event.LoadAccountSetupState)
+
+        assertThatAndMviTurbinesConsumed(
+            actual = turbines.awaitStateItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(
+                State(
+                    protocolType = IncomingProtocolType.IMAP,
+                    server = StringInputField(value = "imap.example.com"),
+                    security = ConnectionSecurity.TLS,
+                    port = NumberInputField(value = 123L),
+                    authenticationType = AuthenticationType.PasswordCleartext,
+                    username = StringInputField(value = "username"),
+                    password = StringInputField(value = "password"),
+                ),
+            )
+        }
+    }
+
+    @Test
+    fun `should change protocol, security and port when ProtocolTypeChanged event is received`() = runTest {
+        val initialState = State(
+            security = ConnectionSecurity.StartTLS,
+            port = NumberInputField(value = ConnectionSecurity.StartTLS.toImapDefaultPort()),
+        )
+        val testSubject = createTestSubject(initialState)
+
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = initialState,
+            event = Event.ProtocolTypeChanged(IncomingProtocolType.POP3),
+            expectedState = State(
+                protocolType = IncomingProtocolType.POP3,
+                security = ConnectionSecurity.TLS,
+                port = NumberInputField(value = ConnectionSecurity.TLS.toPop3DefaultPort()),
+            ),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when ServerChanged event is received`() = runTest {
+        val initialState = State()
+        eventStateTest(
+            viewModel = createTestSubject(initialState),
+            initialState = initialState,
+            event = Event.ServerChanged("server"),
+            expectedState = State(server = StringInputField(value = "server")),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change security and port when SecurityChanged event is received`() = runTest {
+        val initialState = State()
+        eventStateTest(
+            viewModel = createTestSubject(initialState),
+            initialState = initialState,
+            event = Event.SecurityChanged(ConnectionSecurity.StartTLS),
+            expectedState = State(
+                security = ConnectionSecurity.StartTLS,
+                port = NumberInputField(value = ConnectionSecurity.StartTLS.toImapDefaultPort()),
+            ),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when PortChanged event is received`() = runTest {
+        val initialState = State()
+        eventStateTest(
+            viewModel = createTestSubject(initialState),
+            initialState = initialState,
+            event = Event.PortChanged(456L),
+            expectedState = State(port = NumberInputField(value = 456L)),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change authentication type when AuthenticationTypeChanged event is received`() = runTest {
+        val initialState = State()
+        eventStateTest(
+            viewModel = createTestSubject(initialState),
+            initialState = initialState,
+            event = Event.AuthenticationTypeChanged(AuthenticationType.PasswordEncrypted),
+            expectedState = State(authenticationType = AuthenticationType.PasswordEncrypted),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when UsernameChanged event is received`() = runTest {
+        val initialState = State()
+        eventStateTest(
+            viewModel = createTestSubject(initialState),
+            initialState = initialState,
+            event = Event.UsernameChanged("username"),
+            expectedState = State(username = StringInputField(value = "username")),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when PasswordChanged event is received`() = runTest {
+        val initialState = State()
+        eventStateTest(
+            viewModel = createTestSubject(initialState),
+            initialState = initialState,
+            event = Event.PasswordChanged("password"),
+            expectedState = State(password = StringInputField(value = "password")),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when ClientCertificateChanged event is received`() = runTest {
+        val initialState = State()
+        eventStateTest(
+            viewModel = createTestSubject(initialState),
+            initialState = initialState,
+            event = Event.ClientCertificateChanged("clientCertificate"),
+            expectedState = State(clientCertificateAlias = "clientCertificate"),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when ImapAutoDetectNamespaceChanged event is received`() = runTest {
+        val initialState = State(imapAutodetectNamespaceEnabled = true)
+        eventStateTest(
+            viewModel = createTestSubject(initialState),
+            initialState = State(imapAutodetectNamespaceEnabled = true),
+            event = Event.ImapAutoDetectNamespaceChanged(false),
+            expectedState = State(imapAutodetectNamespaceEnabled = false),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when ImapPrefixChanged event is received`() = runTest {
+        val initialState = State()
+        eventStateTest(
+            viewModel = createTestSubject(initialState),
+            initialState = initialState,
+            event = Event.ImapPrefixChanged("imapPrefix"),
+            expectedState = State(imapPrefix = StringInputField(value = "imapPrefix")),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when ImapUseCompressionChanged event is received`() = runTest {
+        val initialState = State(imapUseCompression = true)
+        eventStateTest(
+            viewModel = createTestSubject(initialState),
+            initialState = initialState,
+            event = Event.ImapUseCompressionChanged(false),
+            expectedState = State(imapUseCompression = false),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when ImapSendClientIdChanged event is received`() = runTest {
+        val initialState = State(imapSendClientId = true)
+        eventStateTest(
+            viewModel = createTestSubject(initialState),
+            initialState = initialState,
+            event = Event.ImapSendClientIdChanged(false),
+            expectedState = State(imapSendClientId = false),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should save state emit effect NavigateNext when OnNextClicked is received and input valid`() = runTest {
+        val initialState = State()
+        val repository = InMemoryAccountSetupStateRepository()
+        val testSubject = createTestSubject(
+            initialState = initialState,
+            repository = repository,
+        )
+        val turbines = turbinesWithInitialStateCheck(testSubject, initialState)
+
+        testSubject.event(Event.OnNextClicked)
+
+        assertThat(turbines.awaitStateItem()).isEqualTo(
+            State(
+                protocolType = IncomingProtocolType.IMAP,
+                server = StringInputField(value = "", isValid = true),
+                port = NumberInputField(value = 993L, isValid = true),
+                authenticationType = AuthenticationType.PasswordCleartext,
+                username = StringInputField(value = "", isValid = true),
+                password = StringInputField(value = "", isValid = true),
+                imapPrefix = StringInputField(value = "", isValid = true),
+            ),
+        )
+
+        assertThat(repository.getState()).isEqualTo(
+            AccountSetupState(
+                incomingServerSettings = ServerSettings(
+                    type = "imap",
+                    host = "",
+                    port = 993,
+                    connectionSecurity = MailConnectionSecurity.SSL_TLS_REQUIRED,
+                    authenticationType = AuthType.PLAIN,
+                    username = "",
+                    password = "",
+                    clientCertificateAlias = null,
+                    extra = mapOf(
+                        "autoDetectNamespace" to "true",
+                        "pathPrefix" to null,
+                        "useCompression" to "true",
+                        "sendClientId" to "true",
+                    ),
+                ),
+            ),
+        )
+
+        assertThatAndMviTurbinesConsumed(
+            actual = turbines.awaitEffectItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(Effect.NavigateNext)
+        }
+    }
+
+    @Test
+    fun `should save state and emit effect NavigateNext when OnNextClicked is received and input valid with OAuth`() =
+        runTest {
+            val initialState = State(
+                authenticationType = AuthenticationType.OAuth2,
+            )
+            val repository = InMemoryAccountSetupStateRepository()
+            val testSubject = createTestSubject(
+                initialState = initialState,
+                repository = repository,
+            )
+            val turbines = turbinesWithInitialStateCheck(testSubject, initialState)
+
+            testSubject.event(Event.OnNextClicked)
+
+            assertThat(turbines.awaitStateItem()).isEqualTo(
+                State(
+                    protocolType = IncomingProtocolType.IMAP,
+                    server = StringInputField(value = "", isValid = true),
+                    port = NumberInputField(value = 993L, isValid = true),
+                    authenticationType = AuthenticationType.OAuth2,
+                    username = StringInputField(value = "", isValid = true),
+                    password = StringInputField(value = "", isValid = true),
+                    imapPrefix = StringInputField(value = "", isValid = true),
+                ),
+            )
+
+            assertThat(repository.getState()).isEqualTo(
+                AccountSetupState(
+                    emailAddress = null,
+                    incomingServerSettings = ServerSettings(
+                        type = "imap",
+                        host = "",
+                        port = 993,
+                        connectionSecurity = MailConnectionSecurity.SSL_TLS_REQUIRED,
+                        authenticationType = AuthType.XOAUTH2,
+                        username = "",
+                        password = null,
+                        clientCertificateAlias = null,
+                        extra = mapOf(
+                            "autoDetectNamespace" to "true",
+                            "pathPrefix" to null,
+                            "useCompression" to "true",
+                            "sendClientId" to "true",
+                        ),
+                    ),
+                ),
+            )
+
+            assertThatAndMviTurbinesConsumed(
+                actual = turbines.awaitEffectItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(Effect.NavigateNext)
+            }
+        }
+
+    @Test
+    fun `should change state and not emit NavigateNext effect when OnNextClicked event received and input invalid`() =
+        runTest {
+            val testSubject = AccountIncomingConfigViewModel(
+                validator = FakeAccountIncomingConfigValidator(
+                    serverAnswer = ValidationResult.Failure(TestError),
+                ),
+                accountSetupStateRepository = InMemoryAccountSetupStateRepository(),
+            )
+            val turbines = turbinesWithInitialStateCheck(testSubject, State())
+
+            testSubject.event(Event.OnNextClicked)
+
+            assertThatAndMviTurbinesConsumed(
+                actual = turbines.awaitStateItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(
+                    State(
+                        server = StringInputField(value = "", error = TestError, isValid = false),
+                        port = NumberInputField(value = 993L, isValid = true),
+                        username = StringInputField(value = "", isValid = true),
+                        password = StringInputField(value = "", isValid = true),
+                        imapPrefix = StringInputField(value = "", isValid = true),
+                    ),
+                )
+            }
+        }
+
+    @Test
+    fun `should emit NavigateBack effect when OnBackClicked event received`() = runTest {
+        val testSubject = createTestSubject(State())
+        val turbines = turbinesWithInitialStateCheck(testSubject, State())
+
+        testSubject.event(Event.OnBackClicked)
+
+        assertThatAndMviTurbinesConsumed(
+            actual = turbines.awaitEffectItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(Effect.NavigateBack)
+        }
+    }
+
+    private object TestError : ValidationError
+
+    private companion object {
+        fun createTestSubject(
+            initialState: State? = null,
+            validator: AccountIncomingConfigContract.Validator = FakeAccountIncomingConfigValidator(),
+            repository: DomainContract.AccountSetupStateRepository = InMemoryAccountSetupStateRepository(),
+        ) = AccountIncomingConfigViewModel(
+            validator = validator,
+            accountSetupStateRepository = repository,
+            initialState = initialState,
+        )
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/incoming/FakeAccountIncomingConfigValidator.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/incoming/FakeAccountIncomingConfigValidator.kt
new file mode 100644
index 0000000000000000000000000000000000000000..9835314489ba7e8fef0ac8ba8135be09e8503714
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/incoming/FakeAccountIncomingConfigValidator.kt
@@ -0,0 +1,17 @@
+package app.k9mail.feature.account.setup.ui.incoming
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+
+class FakeAccountIncomingConfigValidator(
+    private val serverAnswer: ValidationResult = ValidationResult.Success,
+    private val portAnswer: ValidationResult = ValidationResult.Success,
+    private val usernameAnswer: ValidationResult = ValidationResult.Success,
+    private val passwordAnswer: ValidationResult = ValidationResult.Success,
+    private val imapPrefixAnswer: ValidationResult = ValidationResult.Success,
+) : AccountIncomingConfigContract.Validator {
+    override fun validateServer(server: String): ValidationResult = serverAnswer
+    override fun validatePort(port: Long?): ValidationResult = portAnswer
+    override fun validateUsername(username: String): ValidationResult = usernameAnswer
+    override fun validatePassword(password: String): ValidationResult = passwordAnswer
+    override fun validateImapPrefix(imapPrefix: String): ValidationResult = imapPrefixAnswer
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/incoming/FakeAccountIncomingConfigViewModel.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/incoming/FakeAccountIncomingConfigViewModel.kt
new file mode 100644
index 0000000000000000000000000000000000000000..3fda4d2e7795830c3fe8956293839be133190bf9
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/incoming/FakeAccountIncomingConfigViewModel.kt
@@ -0,0 +1,22 @@
+package app.k9mail.feature.account.setup.ui.incoming
+
+import app.k9mail.core.ui.compose.common.mvi.BaseViewModel
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.Effect
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.Event
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.State
+import app.k9mail.feature.account.setup.ui.incoming.AccountIncomingConfigContract.ViewModel
+
+class FakeAccountIncomingConfigViewModel(
+    initialState: State = State(),
+) : BaseViewModel<State, Event, Effect>(initialState), ViewModel {
+
+    val events = mutableListOf<Event>()
+
+    override fun event(event: Event) {
+        events.add(event)
+    }
+
+    fun effect(effect: Effect) {
+        emitEffect(effect)
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsScreenKtTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsScreenKtTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..e804873612261ccb6cff3ffb3def781e53a6e494
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsScreenKtTest.kt
@@ -0,0 +1,45 @@
+package app.k9mail.feature.account.setup.ui.options
+
+import app.k9mail.core.ui.compose.testing.ComposeTest
+import app.k9mail.core.ui.compose.testing.setContent
+import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.Effect
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.State
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+class AccountOptionsScreenKtTest : ComposeTest() {
+
+    @Test
+    fun `should delegate navigation effects`() = runTest {
+        val initialState = State()
+        val viewModel = FakeAccountOptionsViewModel(initialState)
+        var onNextCounter = 0
+        var onBackCounter = 0
+
+        setContent {
+            ThunderbirdTheme {
+                AccountOptionsScreen(
+                    onNext = { onNextCounter++ },
+                    onBack = { onBackCounter++ },
+                    viewModel = viewModel,
+                )
+            }
+        }
+
+        assertThat(onNextCounter).isEqualTo(0)
+        assertThat(onBackCounter).isEqualTo(0)
+
+        viewModel.effect(Effect.NavigateNext)
+
+        assertThat(onNextCounter).isEqualTo(1)
+        assertThat(onBackCounter).isEqualTo(0)
+
+        viewModel.effect(Effect.NavigateBack)
+
+        assertThat(onNextCounter).isEqualTo(1)
+        assertThat(onBackCounter).isEqualTo(1)
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsStateMapperKtTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsStateMapperKtTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..4ef8082def54db9776b9065459c8384ac01b06a9
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsStateMapperKtTest.kt
@@ -0,0 +1,47 @@
+package app.k9mail.feature.account.setup.ui.options
+
+import app.k9mail.feature.account.setup.domain.entity.AccountOptions
+import app.k9mail.feature.account.setup.domain.entity.EmailCheckFrequency
+import app.k9mail.feature.account.setup.domain.entity.EmailDisplayCount
+import app.k9mail.feature.account.setup.domain.input.StringInputField
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.isNull
+import org.junit.Test
+
+class AccountOptionsStateMapperKtTest {
+
+    @Test
+    fun `should map state to account options`() {
+        val state = AccountOptionsContract.State(
+            accountName = StringInputField("accountName"),
+            displayName = StringInputField("displayName"),
+            emailSignature = StringInputField("emailSignature"),
+            checkFrequency = EmailCheckFrequency.EVERY_2_HOURS,
+            messageDisplayCount = EmailDisplayCount.MESSAGES_100,
+            showNotification = true,
+        )
+
+        val result = state.toAccountOptions()
+
+        assertThat(result).isEqualTo(
+            AccountOptions(
+                accountName = "accountName",
+                displayName = "displayName",
+                emailSignature = "emailSignature",
+                checkFrequencyInMinutes = 120,
+                messageDisplayCount = 100,
+                showNotification = true,
+            ),
+        )
+    }
+
+    @Test
+    fun `empty signature should map to null`() {
+        val state = AccountOptionsContract.State(emailSignature = StringInputField(""))
+
+        val result = state.toAccountOptions()
+
+        assertThat(result.emailSignature).isNull()
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsStateTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsStateTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..eeb7ec44e4eebc88fd771a5f70211badba0ad895
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsStateTest.kt
@@ -0,0 +1,28 @@
+package app.k9mail.feature.account.setup.ui.options
+
+import app.k9mail.feature.account.setup.domain.entity.EmailCheckFrequency
+import app.k9mail.feature.account.setup.domain.entity.EmailDisplayCount
+import app.k9mail.feature.account.setup.domain.input.StringInputField
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.State
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import org.junit.Test
+
+class AccountOptionsStateTest {
+
+    @Test
+    fun `should set default values`() {
+        val state = State()
+
+        assertThat(state).isEqualTo(
+            State(
+                accountName = StringInputField(),
+                displayName = StringInputField(),
+                emailSignature = StringInputField(),
+                checkFrequency = EmailCheckFrequency.DEFAULT,
+                messageDisplayCount = EmailDisplayCount.DEFAULT,
+                showNotification = false,
+            ),
+        )
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsViewModelTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsViewModelTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..a47689aca080d9d351fc7d224e7f7136781ef13e
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/options/AccountOptionsViewModelTest.kt
@@ -0,0 +1,194 @@
+package app.k9mail.feature.account.setup.ui.options
+
+import app.cash.turbine.testIn
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.core.ui.compose.testing.MainDispatcherRule
+import app.k9mail.core.ui.compose.testing.mvi.eventStateTest
+import app.k9mail.feature.account.setup.data.InMemoryAccountSetupStateRepository
+import app.k9mail.feature.account.setup.domain.entity.EmailCheckFrequency
+import app.k9mail.feature.account.setup.domain.entity.EmailDisplayCount
+import app.k9mail.feature.account.setup.domain.input.StringInputField
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.Effect
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.Event
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.State
+import assertk.assertThat
+import assertk.assertions.assertThatAndTurbinesConsumed
+import assertk.assertions.isEqualTo
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.runTest
+import org.junit.Rule
+import org.junit.Test
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class AccountOptionsViewModelTest {
+
+    @get:Rule
+    val mainDispatcherRule = MainDispatcherRule()
+
+    private val testSubject = AccountOptionsViewModel(
+        validator = FakeAccountOptionsValidator(),
+        accountSetupStateRepository = InMemoryAccountSetupStateRepository(),
+    )
+
+    @Test
+    fun `should change state when OnAccountNameChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = State(),
+            event = Event.OnAccountNameChanged("accountName"),
+            expectedState = State(accountName = StringInputField(value = "accountName")),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when OnDisplayNameChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = State(),
+            event = Event.OnDisplayNameChanged("displayName"),
+            expectedState = State(displayName = StringInputField(value = "displayName")),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when OnEmailSignatureChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = State(),
+            event = Event.OnEmailSignatureChanged("emailSignature"),
+            expectedState = State(emailSignature = StringInputField(value = "emailSignature")),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when OnCheckFrequencyChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = State(),
+            event = Event.OnCheckFrequencyChanged(EmailCheckFrequency.EVERY_12_HOURS),
+            expectedState = State(checkFrequency = EmailCheckFrequency.EVERY_12_HOURS),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when OnMessageDisplayCountChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = State(),
+            event = Event.OnMessageDisplayCountChanged(EmailDisplayCount.MESSAGES_1000),
+            expectedState = State(messageDisplayCount = EmailDisplayCount.MESSAGES_1000),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when OnShowNotificationChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = testSubject,
+            initialState = State(),
+            event = Event.OnShowNotificationChanged(true),
+            expectedState = State(showNotification = true),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state and emit NavigateNext effect when OnNextClicked event received and input valid`() =
+        runTest {
+            val viewModel = testSubject
+            val stateTurbine = viewModel.state.testIn(backgroundScope)
+            val effectTurbine = viewModel.effect.testIn(backgroundScope)
+            val turbines = listOf(stateTurbine, effectTurbine)
+
+            assertThatAndTurbinesConsumed(
+                actual = stateTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(State())
+            }
+
+            viewModel.event(Event.OnNextClicked)
+
+            assertThat(stateTurbine.awaitItem()).isEqualTo(
+                State(
+                    accountName = StringInputField(value = "", isValid = true),
+                    displayName = StringInputField(value = "", isValid = true),
+                    emailSignature = StringInputField(value = "", isValid = true),
+                ),
+            )
+
+            assertThatAndTurbinesConsumed(
+                actual = effectTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(Effect.NavigateNext)
+            }
+        }
+
+    @Test
+    fun `should change state and not emit effect when OnNextClicked event received and input invalid`() =
+        runTest {
+            val viewModel = AccountOptionsViewModel(
+                validator = FakeAccountOptionsValidator(
+                    accountNameAnswer = ValidationResult.Failure(TestError),
+                ),
+                accountSetupStateRepository = InMemoryAccountSetupStateRepository(),
+            )
+            val stateTurbine = viewModel.state.testIn(backgroundScope)
+            val effectTurbine = viewModel.effect.testIn(backgroundScope)
+            val turbines = listOf(stateTurbine, effectTurbine)
+
+            assertThatAndTurbinesConsumed(
+                actual = stateTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(State())
+            }
+
+            viewModel.event(Event.OnNextClicked)
+
+            assertThatAndTurbinesConsumed(
+                actual = stateTurbine.awaitItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(
+                    State(
+                        accountName = StringInputField(value = "", error = TestError, isValid = false),
+                        displayName = StringInputField(value = "", isValid = true),
+                        emailSignature = StringInputField(value = "", isValid = true),
+                    ),
+                )
+            }
+        }
+
+    @Test
+    fun `should emit NavigateBack effect when OnBackClicked event received`() = runTest {
+        val viewModel = testSubject
+        val stateTurbine = viewModel.state.testIn(backgroundScope)
+        val effectTurbine = viewModel.effect.testIn(backgroundScope)
+        val turbines = listOf(stateTurbine, effectTurbine)
+
+        assertThatAndTurbinesConsumed(
+            actual = stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(State())
+        }
+
+        viewModel.event(Event.OnBackClicked)
+
+        assertThatAndTurbinesConsumed(
+            actual = effectTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(Effect.NavigateBack)
+        }
+    }
+
+    private object TestError : ValidationError
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/options/FakeAccountOptionsValidator.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/options/FakeAccountOptionsValidator.kt
new file mode 100644
index 0000000000000000000000000000000000000000..bd65543c2dacaf7843ae19a7ea81a72744ecebde
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/options/FakeAccountOptionsValidator.kt
@@ -0,0 +1,14 @@
+package app.k9mail.feature.account.setup.ui.options
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.Validator
+
+internal class FakeAccountOptionsValidator(
+    private val accountNameAnswer: ValidationResult = ValidationResult.Success,
+    private val displayNameAnswer: ValidationResult = ValidationResult.Success,
+    private val emailSignatureAnswer: ValidationResult = ValidationResult.Success,
+) : Validator {
+    override fun validateAccountName(accountName: String): ValidationResult = accountNameAnswer
+    override fun validateDisplayName(displayName: String): ValidationResult = displayNameAnswer
+    override fun validateEmailSignature(emailSignature: String): ValidationResult = emailSignatureAnswer
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/options/FakeAccountOptionsViewModel.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/options/FakeAccountOptionsViewModel.kt
new file mode 100644
index 0000000000000000000000000000000000000000..e715283ef1aa14b1cb61c419aa57ba79fda6c508
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/options/FakeAccountOptionsViewModel.kt
@@ -0,0 +1,22 @@
+package app.k9mail.feature.account.setup.ui.options
+
+import app.k9mail.core.ui.compose.common.mvi.BaseViewModel
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.Effect
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.Event
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.State
+import app.k9mail.feature.account.setup.ui.options.AccountOptionsContract.ViewModel
+
+class FakeAccountOptionsViewModel(
+    initialState: State = State(),
+) : BaseViewModel<State, Event, Effect>(initialState), ViewModel {
+
+    val events = mutableListOf<Event>()
+
+    override fun event(event: Event) {
+        events.add(event)
+    }
+
+    fun effect(effect: Effect) {
+        emitEffect(effect)
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigScreenKtTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigScreenKtTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..0de96e850dbaad0a3f55e6372782c31fe85875ba
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigScreenKtTest.kt
@@ -0,0 +1,42 @@
+package app.k9mail.feature.account.setup.ui.outgoing
+
+import app.k9mail.core.ui.compose.testing.ComposeTest
+import app.k9mail.core.ui.compose.testing.setContent
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.Effect
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.State
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+class AccountOutgoingConfigScreenKtTest : ComposeTest() {
+
+    @Test
+    fun `should delegate navigation effects`() = runTest {
+        val initialState = State()
+        val viewModel = FakeAccountOutgoingConfigViewModel(initialState)
+        var onNextCounter = 0
+        var onBackCounter = 0
+
+        setContent {
+            AccountOutgoingConfigScreen(
+                onNext = { onNextCounter++ },
+                onBack = { onBackCounter++ },
+                viewModel = viewModel,
+            )
+        }
+
+        assertThat(onNextCounter).isEqualTo(0)
+        assertThat(onBackCounter).isEqualTo(0)
+
+        viewModel.effect(Effect.NavigateNext)
+
+        assertThat(onNextCounter).isEqualTo(1)
+        assertThat(onBackCounter).isEqualTo(0)
+
+        viewModel.effect(Effect.NavigateBack)
+
+        assertThat(onNextCounter).isEqualTo(1)
+        assertThat(onBackCounter).isEqualTo(1)
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigStateMapperKtTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigStateMapperKtTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..b4d47c10f17351cf073614894cc6cca027c6e2ec
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigStateMapperKtTest.kt
@@ -0,0 +1,44 @@
+package app.k9mail.feature.account.setup.ui.outgoing
+
+import app.k9mail.feature.account.setup.domain.entity.AuthenticationType
+import app.k9mail.feature.account.setup.domain.entity.ConnectionSecurity
+import app.k9mail.feature.account.setup.domain.entity.MailConnectionSecurity
+import app.k9mail.feature.account.setup.domain.input.NumberInputField
+import app.k9mail.feature.account.setup.domain.input.StringInputField
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.State
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import com.fsck.k9.mail.AuthType
+import com.fsck.k9.mail.ServerSettings
+import org.junit.Test
+
+class AccountOutgoingConfigStateMapperKtTest {
+
+    @Test
+    fun `should map to server settings`() {
+        val outgoingState = State(
+            server = StringInputField(value = "smtp.example.org"),
+            port = NumberInputField(value = 587),
+            security = ConnectionSecurity.TLS,
+            authenticationType = AuthenticationType.PasswordCleartext,
+            username = StringInputField(value = "user"),
+            password = StringInputField(value = "password"),
+            clientCertificateAlias = null,
+        )
+
+        val result = outgoingState.toServerSettings()
+
+        assertThat(result).isEqualTo(
+            ServerSettings(
+                type = "smtp",
+                host = "smtp.example.org",
+                port = 587,
+                connectionSecurity = MailConnectionSecurity.SSL_TLS_REQUIRED,
+                authenticationType = AuthType.PLAIN,
+                username = "user",
+                password = "password",
+                clientCertificateAlias = null,
+            ),
+        )
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigStateTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigStateTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..840fbe5601029abef0b13bf66b72a685cc2f1731
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigStateTest.kt
@@ -0,0 +1,31 @@
+package app.k9mail.feature.account.setup.ui.outgoing
+
+import app.k9mail.feature.account.setup.domain.entity.AuthenticationType
+import app.k9mail.feature.account.setup.domain.entity.ConnectionSecurity
+import app.k9mail.feature.account.setup.domain.entity.toSmtpDefaultPort
+import app.k9mail.feature.account.setup.domain.input.NumberInputField
+import app.k9mail.feature.account.setup.domain.input.StringInputField
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.State
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import org.junit.Test
+
+class AccountOutgoingConfigStateTest {
+
+    @Test
+    fun `should set default values`() {
+        val state = State()
+
+        assertThat(state).isEqualTo(
+            State(
+                server = StringInputField(),
+                security = ConnectionSecurity.DEFAULT,
+                port = NumberInputField(value = ConnectionSecurity.DEFAULT.toSmtpDefaultPort()),
+                authenticationType = AuthenticationType.PasswordCleartext,
+                username = StringInputField(),
+                password = StringInputField(),
+                clientCertificateAlias = null,
+            ),
+        )
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigViewModelTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigViewModelTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..1d6c57625bdcb98a68cb0bce915d253bff30426f
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/outgoing/AccountOutgoingConfigViewModelTest.kt
@@ -0,0 +1,351 @@
+package app.k9mail.feature.account.setup.ui.outgoing
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationError
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+import app.k9mail.core.ui.compose.testing.MainDispatcherRule
+import app.k9mail.core.ui.compose.testing.mvi.assertThatAndMviTurbinesConsumed
+import app.k9mail.core.ui.compose.testing.mvi.eventStateTest
+import app.k9mail.core.ui.compose.testing.mvi.turbines
+import app.k9mail.core.ui.compose.testing.mvi.turbinesWithInitialStateCheck
+import app.k9mail.feature.account.setup.data.InMemoryAccountSetupStateRepository
+import app.k9mail.feature.account.setup.domain.DomainContract
+import app.k9mail.feature.account.setup.domain.entity.AccountSetupState
+import app.k9mail.feature.account.setup.domain.entity.AuthenticationType
+import app.k9mail.feature.account.setup.domain.entity.ConnectionSecurity
+import app.k9mail.feature.account.setup.domain.entity.MailConnectionSecurity
+import app.k9mail.feature.account.setup.domain.entity.toSmtpDefaultPort
+import app.k9mail.feature.account.setup.domain.input.NumberInputField
+import app.k9mail.feature.account.setup.domain.input.StringInputField
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.Effect
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.Event
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.State
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import com.fsck.k9.mail.AuthType
+import com.fsck.k9.mail.ServerSettings
+import kotlinx.coroutines.test.runTest
+import org.junit.Rule
+import org.junit.Test
+
+class AccountOutgoingConfigViewModelTest {
+
+    @get:Rule
+    val mainDispatcherRule = MainDispatcherRule()
+
+    @Test
+    fun `should take initial state from repository when no initial state is provided`() = runTest {
+        val accountSetupState = AccountSetupState(
+            emailAddress = "test@example.com",
+            outgoingServerSettings = ServerSettings(
+                "smtp",
+                "smtp.example.com",
+                123,
+                MailConnectionSecurity.SSL_TLS_REQUIRED,
+                AuthType.PLAIN,
+                "username",
+                "password",
+                clientCertificateAlias = null,
+                extra = emptyMap(),
+            ),
+        )
+        val testSubject = createTestSubject(
+            initialState = null,
+            repository = InMemoryAccountSetupStateRepository(accountSetupState),
+        )
+        val turbines = turbines(testSubject)
+
+        assertThatAndMviTurbinesConsumed(
+            actual = turbines.awaitStateItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(
+                State(
+                    server = StringInputField(value = "smtp.example.com"),
+                    security = ConnectionSecurity.TLS,
+                    port = NumberInputField(value = 123L),
+                    authenticationType = AuthenticationType.PasswordCleartext,
+                    username = StringInputField(value = "username"),
+                    password = StringInputField(value = "password"),
+                ),
+            )
+        }
+    }
+
+    @Test
+    fun `should load account setup state when LoadAccountSetupState event is received`() = runTest {
+        val accountSetupState = AccountSetupState(
+            emailAddress = "test@example.com",
+            outgoingServerSettings = ServerSettings(
+                "smtp",
+                "smtp.example.com",
+                123,
+                MailConnectionSecurity.SSL_TLS_REQUIRED,
+                AuthType.PLAIN,
+                "username",
+                "password",
+                clientCertificateAlias = null,
+                extra = emptyMap(),
+            ),
+        )
+        val repository = InMemoryAccountSetupStateRepository(AccountSetupState())
+        val testSubject = createTestSubject(
+            initialState = null,
+            repository = repository,
+        )
+        val turbines = turbinesWithInitialStateCheck(testSubject, State())
+
+        repository.save(accountSetupState)
+
+        testSubject.event(Event.LoadAccountSetupState)
+
+        assertThatAndMviTurbinesConsumed(
+            actual = turbines.awaitStateItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(
+                State(
+                    server = StringInputField(value = "smtp.example.com"),
+                    security = ConnectionSecurity.TLS,
+                    port = NumberInputField(value = 123L),
+                    authenticationType = AuthenticationType.PasswordCleartext,
+                    username = StringInputField(value = "username"),
+                    password = StringInputField(value = "password"),
+                ),
+            )
+        }
+    }
+
+    @Test
+    fun `should change state when ServerChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = createTestSubject(State()),
+            initialState = State(),
+            event = Event.ServerChanged("server"),
+            expectedState = State(server = StringInputField(value = "server")),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change security and port when SecurityChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = createTestSubject(State()),
+            initialState = State(),
+            event = Event.SecurityChanged(ConnectionSecurity.StartTLS),
+            expectedState = State(
+                security = ConnectionSecurity.StartTLS,
+                port = NumberInputField(value = ConnectionSecurity.StartTLS.toSmtpDefaultPort()),
+            ),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when PortChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = createTestSubject(State()),
+            initialState = State(),
+            event = Event.PortChanged(456L),
+            expectedState = State(port = NumberInputField(value = 456L)),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when AuthenticationTypeChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = createTestSubject(State()),
+            initialState = State(),
+            event = Event.AuthenticationTypeChanged(AuthenticationType.PasswordEncrypted),
+            expectedState = State(authenticationType = AuthenticationType.PasswordEncrypted),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when UsernameChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = createTestSubject(State()),
+            initialState = State(),
+            event = Event.UsernameChanged("username"),
+            expectedState = State(username = StringInputField(value = "username")),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when PasswordChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = createTestSubject(State()),
+            initialState = State(),
+            event = Event.PasswordChanged("password"),
+            expectedState = State(password = StringInputField(value = "password")),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should change state when ClientCertificateChanged event is received`() = runTest {
+        eventStateTest(
+            viewModel = createTestSubject(State()),
+            initialState = State(),
+            event = Event.ClientCertificateChanged("clientCertificate"),
+            expectedState = State(clientCertificateAlias = "clientCertificate"),
+            coroutineScope = backgroundScope,
+        )
+    }
+
+    @Test
+    fun `should save state and emit effect NavigateNext when OnNextClicked is received and input valid`() = runTest {
+        val initialState = State()
+        val repository = InMemoryAccountSetupStateRepository()
+        val testSubject = createTestSubject(
+            initialState = initialState,
+            repository = repository,
+        )
+        val turbines = turbinesWithInitialStateCheck(testSubject, initialState)
+
+        testSubject.event(Event.OnNextClicked)
+
+        assertThat(turbines.awaitStateItem()).isEqualTo(
+            State(
+                server = StringInputField(value = "", isValid = true),
+                port = NumberInputField(value = 465L, isValid = true),
+                authenticationType = AuthenticationType.PasswordCleartext,
+                username = StringInputField(value = "", isValid = true),
+                password = StringInputField(value = "", isValid = true),
+            ),
+        )
+
+        assertThat(repository.getState()).isEqualTo(
+            AccountSetupState(
+                outgoingServerSettings = ServerSettings(
+                    type = "smtp",
+                    host = "",
+                    port = 465,
+                    connectionSecurity = MailConnectionSecurity.SSL_TLS_REQUIRED,
+                    authenticationType = AuthType.PLAIN,
+                    username = "",
+                    password = "",
+                    clientCertificateAlias = null,
+                    extra = emptyMap(),
+                ),
+            ),
+        )
+
+        assertThatAndMviTurbinesConsumed(
+            actual = turbines.awaitEffectItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(Effect.NavigateNext)
+        }
+    }
+
+    @Test
+    fun `should save state and emit effect NavigateNext when OnNextClicked is received and input valid with OAuth`() =
+        runTest {
+            val initialState = State(
+                authenticationType = AuthenticationType.OAuth2,
+            )
+            val repository = InMemoryAccountSetupStateRepository()
+            val testSubject = createTestSubject(
+                initialState = initialState,
+                repository = repository,
+            )
+            val turbines = turbinesWithInitialStateCheck(testSubject, initialState)
+
+            testSubject.event(Event.OnNextClicked)
+
+            assertThat(turbines.awaitStateItem()).isEqualTo(
+                State(
+                    server = StringInputField(value = "", isValid = true),
+                    port = NumberInputField(value = 465L, isValid = true),
+                    authenticationType = AuthenticationType.OAuth2,
+                    username = StringInputField(value = "", isValid = true),
+                    password = StringInputField(value = "", isValid = true),
+                ),
+            )
+
+            assertThat(repository.getState()).isEqualTo(
+                AccountSetupState(
+                    outgoingServerSettings = ServerSettings(
+                        type = "smtp",
+                        host = "",
+                        port = 465,
+                        connectionSecurity = MailConnectionSecurity.SSL_TLS_REQUIRED,
+                        authenticationType = AuthType.XOAUTH2,
+                        username = "",
+                        password = null,
+                        clientCertificateAlias = null,
+                        extra = emptyMap(),
+                    ),
+                ),
+            )
+
+            assertThatAndMviTurbinesConsumed(
+                actual = turbines.awaitEffectItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(Effect.NavigateNext)
+            }
+        }
+
+    @Test
+    fun `should change state and not emit NavigateNext effect when OnNextClicked event received and input invalid`() =
+        runTest {
+            val initialState = State()
+            val testSubject = createTestSubject(
+                validator = FakeAccountOutgoingConfigValidator(
+                    serverAnswer = ValidationResult.Failure(TestError),
+                ),
+                initialState = initialState,
+            )
+            val turbines = turbinesWithInitialStateCheck(testSubject, initialState)
+
+            testSubject.event(Event.OnNextClicked)
+
+            assertThatAndMviTurbinesConsumed(
+                actual = turbines.awaitStateItem(),
+                turbines = turbines,
+            ) {
+                isEqualTo(
+                    State(
+                        server = StringInputField(value = "", error = TestError, isValid = false),
+                        port = NumberInputField(value = 465L, isValid = true),
+                        username = StringInputField(value = "", isValid = true),
+                        password = StringInputField(value = "", isValid = true),
+                    ),
+                )
+            }
+        }
+
+    @Test
+    fun `should emit NavigateBack effect when OnBackClicked event received`() = runTest {
+        val initialState = State()
+        val testSubject = createTestSubject(initialState)
+        val turbines = turbinesWithInitialStateCheck(testSubject, initialState)
+
+        testSubject.event(Event.OnBackClicked)
+
+        assertThatAndMviTurbinesConsumed(
+            actual = turbines.awaitEffectItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(Effect.NavigateBack)
+        }
+    }
+
+    private object TestError : ValidationError
+
+    private companion object {
+        fun createTestSubject(
+            initialState: State? = null,
+            validator: AccountOutgoingConfigContract.Validator = FakeAccountOutgoingConfigValidator(),
+            repository: DomainContract.AccountSetupStateRepository = InMemoryAccountSetupStateRepository(),
+        ) = AccountOutgoingConfigViewModel(
+            validator = validator,
+            accountSetupStateRepository = repository,
+            initialState = initialState,
+        )
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/outgoing/FakeAccountOutgoingConfigValidator.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/outgoing/FakeAccountOutgoingConfigValidator.kt
new file mode 100644
index 0000000000000000000000000000000000000000..5c342e99592cbac10b0d96443e83043e5a4a0119
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/outgoing/FakeAccountOutgoingConfigValidator.kt
@@ -0,0 +1,15 @@
+package app.k9mail.feature.account.setup.ui.outgoing
+
+import app.k9mail.core.common.domain.usecase.validation.ValidationResult
+
+class FakeAccountOutgoingConfigValidator(
+    private val serverAnswer: ValidationResult = ValidationResult.Success,
+    private val portAnswer: ValidationResult = ValidationResult.Success,
+    private val usernameAnswer: ValidationResult = ValidationResult.Success,
+    private val passwordAnswer: ValidationResult = ValidationResult.Success,
+) : AccountOutgoingConfigContract.Validator {
+    override fun validateServer(server: String): ValidationResult = serverAnswer
+    override fun validatePort(port: Long?): ValidationResult = portAnswer
+    override fun validateUsername(username: String): ValidationResult = usernameAnswer
+    override fun validatePassword(password: String): ValidationResult = passwordAnswer
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/outgoing/FakeAccountOutgoingConfigViewModel.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/outgoing/FakeAccountOutgoingConfigViewModel.kt
new file mode 100644
index 0000000000000000000000000000000000000000..0c2838600c8a24bbf162167877e7d8986e0f2cc3
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/outgoing/FakeAccountOutgoingConfigViewModel.kt
@@ -0,0 +1,22 @@
+package app.k9mail.feature.account.setup.ui.outgoing
+
+import app.k9mail.core.ui.compose.common.mvi.BaseViewModel
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.Effect
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.Event
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.State
+import app.k9mail.feature.account.setup.ui.outgoing.AccountOutgoingConfigContract.ViewModel
+
+class FakeAccountOutgoingConfigViewModel(
+    initialState: State = State(),
+) : BaseViewModel<State, Event, Effect>(initialState), ViewModel {
+
+    val events = mutableListOf<Event>()
+
+    override fun event(event: Event) {
+        events.add(event)
+    }
+
+    fun effect(effect: Effect) {
+        emitEffect(effect)
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/validation/AccountValidationScreenKtTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/validation/AccountValidationScreenKtTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..eb3710914d9c80e1cfba0adbf0f84bea5df373d1
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/validation/AccountValidationScreenKtTest.kt
@@ -0,0 +1,45 @@
+package app.k9mail.feature.account.setup.ui.validation
+
+import app.k9mail.core.ui.compose.testing.ComposeTest
+import app.k9mail.core.ui.compose.testing.setContent
+import app.k9mail.core.ui.compose.theme.ThunderbirdTheme
+import app.k9mail.feature.account.setup.ui.validation.AccountValidationContract.Effect
+import app.k9mail.feature.account.setup.ui.validation.AccountValidationContract.State
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+class AccountValidationScreenKtTest : ComposeTest() {
+
+    @Test
+    fun `should delegate navigation effects`() = runTest {
+        val initialState = State()
+        val viewModel = FakeAccountValidationViewModel(initialState = initialState)
+        var onNextCounter = 0
+        var onBackCounter = 0
+
+        setContent {
+            ThunderbirdTheme {
+                AccountValidationScreen(
+                    onNext = { onNextCounter++ },
+                    onBack = { onBackCounter++ },
+                    viewModel = viewModel,
+                )
+            }
+        }
+
+        assertThat(onNextCounter).isEqualTo(0)
+        assertThat(onBackCounter).isEqualTo(0)
+
+        viewModel.effect(Effect.NavigateNext)
+
+        assertThat(onNextCounter).isEqualTo(1)
+        assertThat(onBackCounter).isEqualTo(0)
+
+        viewModel.effect(Effect.NavigateBack)
+
+        assertThat(onNextCounter).isEqualTo(1)
+        assertThat(onBackCounter).isEqualTo(1)
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/validation/AccountValidationStateTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/validation/AccountValidationStateTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..ca29ffb3d74510d531a685f481218d08590329b6
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/validation/AccountValidationStateTest.kt
@@ -0,0 +1,23 @@
+package app.k9mail.feature.account.setup.ui.validation
+
+import app.k9mail.feature.account.setup.ui.validation.AccountValidationContract.State
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import org.junit.Test
+
+class AccountValidationStateTest {
+
+    @Test
+    fun `should set default values`() {
+        val state = State()
+
+        assertThat(state).isEqualTo(
+            State(
+                serverSettings = null,
+                isSuccess = false,
+                error = null,
+                isLoading = false,
+            ),
+        )
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/validation/AccountValidationViewModelTest.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/validation/AccountValidationViewModelTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..f64341ded11d688c0a93b8319ace40ece4e18948
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/validation/AccountValidationViewModelTest.kt
@@ -0,0 +1,258 @@
+package app.k9mail.feature.account.setup.ui.validation
+
+import app.k9mail.core.ui.compose.testing.MainDispatcherRule
+import app.k9mail.core.ui.compose.testing.mvi.assertThatAndMviTurbinesConsumed
+import app.k9mail.core.ui.compose.testing.mvi.turbinesWithInitialStateCheck
+import app.k9mail.feature.account.setup.data.InMemoryAccountSetupStateRepository
+import app.k9mail.feature.account.setup.data.InMemoryCertificateErrorRepository
+import app.k9mail.feature.account.setup.domain.entity.AccountSetupState
+import app.k9mail.feature.account.setup.ui.FakeAccountOAuthViewModel
+import app.k9mail.feature.account.setup.ui.validation.AccountValidationContract.Effect
+import app.k9mail.feature.account.setup.ui.validation.AccountValidationContract.Error
+import app.k9mail.feature.account.setup.ui.validation.AccountValidationContract.Event
+import app.k9mail.feature.account.setup.ui.validation.AccountValidationContract.State
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.isTrue
+import com.fsck.k9.mail.AuthType
+import com.fsck.k9.mail.ConnectionSecurity
+import com.fsck.k9.mail.ServerSettings
+import com.fsck.k9.mail.server.ServerSettingsValidationResult
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.test.runTest
+import org.junit.Rule
+import org.junit.Test
+
+class AccountValidationViewModelTest {
+
+    @get:Rule
+    val mainDispatcherRule = MainDispatcherRule()
+
+    @Test
+    fun `should update state when LoadAccountSetupStateAndValidate event received and validate`() = runTest {
+        val accountSetupState = AccountSetupState(
+            incomingServerSettings = IMAP_SERVER_SETTINGS,
+        )
+        val initialState = State(
+            serverSettings = null,
+            isLoading = true,
+            error = Error.ServerError("server error"),
+            isSuccess = true,
+        )
+        val testSubject = createTestSubject(
+            accountSetupState = accountSetupState,
+            initialState = initialState,
+        )
+
+        val turbines = turbinesWithInitialStateCheck(testSubject, initialState)
+
+        val expectedState = State(
+            serverSettings = IMAP_SERVER_SETTINGS,
+            isLoading = false,
+            error = null,
+            isSuccess = false,
+        )
+
+        testSubject.event(Event.LoadAccountSetupStateAndValidate)
+
+        assertThat(turbines.awaitStateItem()).isEqualTo(expectedState)
+
+        val loadingState = expectedState.copy(isLoading = true)
+
+        assertThat(turbines.awaitStateItem()).isEqualTo(loadingState)
+
+        val successState = loadingState.copy(isLoading = false, isSuccess = true)
+
+        assertThatAndMviTurbinesConsumed(
+            actual = turbines.stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(successState)
+        }
+    }
+
+    @Test
+    fun `should fail when ValidateServerSettings event received and server settings null`() = runTest {
+        val initialState = State()
+        val testSubject = createTestSubject()
+        val turbines = turbinesWithInitialStateCheck(testSubject, initialState)
+
+        testSubject.event(Event.ValidateServerSettings)
+
+        val errorState = initialState.copy(
+            error = Error.UnknownError("Server settings not set"),
+        )
+        assertThatAndMviTurbinesConsumed(
+            actual = turbines.stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(errorState)
+        }
+    }
+
+    @Test
+    fun `should validate server settings when ValidateServerSettings event received`() = runTest {
+        val initialState = State(
+            serverSettings = IMAP_SERVER_SETTINGS,
+        )
+        val testSubject = createTestSubject(
+            serverSettingsValidationResult = ServerSettingsValidationResult.Success,
+            initialState = initialState,
+        )
+        val turbines = turbinesWithInitialStateCheck(testSubject, initialState)
+
+        testSubject.event(Event.ValidateServerSettings)
+
+        val loadingState = initialState.copy(isLoading = true)
+        assertThat(turbines.stateTurbine.awaitItem()).isEqualTo(loadingState)
+
+        val successState = loadingState.copy(
+            isLoading = false,
+            isSuccess = true,
+        )
+        assertThat(turbines.stateTurbine.awaitItem()).isEqualTo(successState)
+
+        assertThatAndMviTurbinesConsumed(
+            actual = turbines.effectTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(Effect.NavigateNext)
+        }
+    }
+
+    @Test
+    fun `should set error state when ValidateServerSettings received and check settings failed`() = runTest {
+        val initialState = State(
+            serverSettings = IMAP_SERVER_SETTINGS,
+        )
+        val testSubject = createTestSubject(
+            serverSettingsValidationResult = ServerSettingsValidationResult.ServerError("server error"),
+            initialState = initialState,
+        )
+        val turbines = turbinesWithInitialStateCheck(testSubject, initialState)
+
+        testSubject.event(Event.ValidateServerSettings)
+
+        val loadingState = initialState.copy(isLoading = true)
+        assertThat(turbines.stateTurbine.awaitItem()).isEqualTo(loadingState)
+
+        val failureState = loadingState.copy(
+            isLoading = false,
+            error = Error.ServerError("server error"),
+        )
+        assertThatAndMviTurbinesConsumed(
+            actual = turbines.stateTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(failureState)
+        }
+    }
+
+    @Test
+    fun `should emit effect NavigateNext when ValidateConfig is successful`() = runTest {
+        val initialState = State(
+            serverSettings = IMAP_SERVER_SETTINGS,
+            isSuccess = true,
+        )
+        val testSubject = createTestSubject(
+            initialState = initialState,
+        )
+        val turbines = turbinesWithInitialStateCheck(testSubject, initialState)
+
+        testSubject.event(Event.ValidateServerSettings)
+
+        assertThatAndMviTurbinesConsumed(
+            actual = turbines.effectTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(Effect.NavigateNext)
+        }
+    }
+
+    @Test
+    fun `should emit NavigateBack effect when OnBackClicked event received`() = runTest {
+        val testSubject = createTestSubject()
+        val turbines = turbinesWithInitialStateCheck(testSubject, State())
+
+        testSubject.event(Event.OnBackClicked)
+
+        assertThatAndMviTurbinesConsumed(
+            actual = turbines.effectTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(Effect.NavigateBack)
+        }
+    }
+
+    @Test
+    fun `should clear error and trigger check settings when OnRetryClicked event received`() = runTest {
+        val initialState = State(
+            serverSettings = IMAP_SERVER_SETTINGS,
+            error = Error.ServerError("server error"),
+        )
+        var checkSettingsCalled = false
+        val testSubject = AccountValidationViewModel(
+            validateServerSettings = {
+                delay(50)
+                checkSettingsCalled = true
+                ServerSettingsValidationResult.Success
+            },
+            accountSetupStateRepository = InMemoryAccountSetupStateRepository(),
+            authorizationStateRepository = { true },
+            certificateErrorRepository = InMemoryCertificateErrorRepository(),
+            oAuthViewModel = FakeAccountOAuthViewModel(),
+            initialState = initialState,
+        )
+        val turbines = turbinesWithInitialStateCheck(testSubject, initialState)
+
+        testSubject.event(Event.OnRetryClicked)
+
+        val stateWithoutError = initialState.copy(error = null)
+        assertThat(turbines.stateTurbine.awaitItem()).isEqualTo(stateWithoutError)
+
+        val loadingState = stateWithoutError.copy(isLoading = true)
+        assertThat(turbines.stateTurbine.awaitItem()).isEqualTo(loadingState)
+
+        val successState = loadingState.copy(isLoading = false, isSuccess = true)
+        assertThat(turbines.stateTurbine.awaitItem()).isEqualTo(successState)
+        assertThat(checkSettingsCalled).isTrue()
+
+        assertThatAndMviTurbinesConsumed(
+            actual = turbines.effectTurbine.awaitItem(),
+            turbines = turbines,
+        ) {
+            isEqualTo(Effect.NavigateNext)
+        }
+    }
+
+    private companion object {
+        fun createTestSubject(
+            serverSettingsValidationResult: ServerSettingsValidationResult = ServerSettingsValidationResult.Success,
+            accountSetupState: AccountSetupState = AccountSetupState(),
+            initialState: State = State(),
+        ): AccountValidationViewModel {
+            return AccountValidationViewModel(
+                validateServerSettings = {
+                    delay(50)
+                    serverSettingsValidationResult
+                },
+                accountSetupStateRepository = InMemoryAccountSetupStateRepository(accountSetupState),
+                authorizationStateRepository = { true },
+                certificateErrorRepository = InMemoryCertificateErrorRepository(),
+                oAuthViewModel = FakeAccountOAuthViewModel(),
+                initialState = initialState,
+            )
+        }
+
+        val IMAP_SERVER_SETTINGS = ServerSettings(
+            type = "imap",
+            host = "imap.example.com",
+            port = 465,
+            connectionSecurity = ConnectionSecurity.SSL_TLS_REQUIRED,
+            authenticationType = AuthType.PLAIN,
+            username = "username",
+            password = "password",
+            clientCertificateAlias = null,
+        )
+    }
+}
diff --git a/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/validation/FakeAccountValidationViewModel.kt b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/validation/FakeAccountValidationViewModel.kt
new file mode 100644
index 0000000000000000000000000000000000000000..41840998e4a24380cfb1ed25eecab9e08534a650
--- /dev/null
+++ b/feature/account/setup/src/test/kotlin/app/k9mail/feature/account/setup/ui/validation/FakeAccountValidationViewModel.kt
@@ -0,0 +1,26 @@
+package app.k9mail.feature.account.setup.ui.validation
+
+import app.k9mail.core.ui.compose.common.mvi.BaseViewModel
+import app.k9mail.feature.account.oauth.ui.AccountOAuthContract
+import app.k9mail.feature.account.setup.ui.FakeAccountOAuthViewModel
+import app.k9mail.feature.account.setup.ui.validation.AccountValidationContract.Effect
+import app.k9mail.feature.account.setup.ui.validation.AccountValidationContract.Event
+import app.k9mail.feature.account.setup.ui.validation.AccountValidationContract.State
+import app.k9mail.feature.account.setup.ui.validation.AccountValidationContract.ViewModel
+
+class FakeAccountValidationViewModel(
+    override val oAuthViewModel: AccountOAuthContract.ViewModel = FakeAccountOAuthViewModel(),
+    override val isIncomingValidation: Boolean = true,
+    initialState: State = State(),
+) : BaseViewModel<State, Event, Effect>(initialState), ViewModel {
+
+    val events = mutableListOf<Event>()
+
+    override fun event(event: Event) {
+        events.add(event)
+    }
+
+    fun effect(effect: Effect) {
+        emitEffect(effect)
+    }
+}
diff --git a/feature/autodiscovery/api/build.gradle.kts b/feature/autodiscovery/api/build.gradle.kts
index 2aa9cf93c5a9d68133963fbb1cecaeeb510cacba..350629b443f54587fa127fe32e746d65219d03f5 100644
--- a/feature/autodiscovery/api/build.gradle.kts
+++ b/feature/autodiscovery/api/build.gradle.kts
@@ -5,4 +5,5 @@ plugins {
 
 dependencies {
     api(projects.mail.common)
+    api(projects.core.common)
 }
diff --git a/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/AuthenticationType.kt b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/AuthenticationType.kt
new file mode 100644
index 0000000000000000000000000000000000000000..8b070af213a9fa361ddc772137ec4b2977910990
--- /dev/null
+++ b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/AuthenticationType.kt
@@ -0,0 +1,13 @@
+package app.k9mail.autodiscovery.api
+
+/**
+ * The authentication types supported when using the [AutoDiscovery] mechanism.
+ *
+ * Note: Currently we support the same set of values in [ImapServerSettings] and [SmtpServerSettings]. As soon as this
+ * changes, this type should be replaced with `ImapAuthenticationType` and `SmtpAuthenticationType`.
+ */
+enum class AuthenticationType {
+    PasswordCleartext,
+    PasswordEncrypted,
+    OAuth2,
+}
diff --git a/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/AutoDiscovery.kt b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/AutoDiscovery.kt
new file mode 100644
index 0000000000000000000000000000000000000000..5f4c43fe5d384387f840d8fcc296962c6ec0cb95
--- /dev/null
+++ b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/AutoDiscovery.kt
@@ -0,0 +1,13 @@
+package app.k9mail.autodiscovery.api
+
+import app.k9mail.core.common.mail.EmailAddress
+
+/**
+ * Provides a mechanism to find mail server settings for a given email address.
+ */
+interface AutoDiscovery {
+    /**
+     * Returns a list of [AutoDiscoveryRunnable]s that perform the actual mail server settings discovery.
+     */
+    fun initDiscovery(email: EmailAddress): List<AutoDiscoveryRunnable>
+}
diff --git a/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/AutoDiscoveryResult.kt b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/AutoDiscoveryResult.kt
new file mode 100644
index 0000000000000000000000000000000000000000..66913d0b958a161a2f90a92b7f9a7cc2c7110d12
--- /dev/null
+++ b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/AutoDiscoveryResult.kt
@@ -0,0 +1,61 @@
+package app.k9mail.autodiscovery.api
+
+import java.io.IOException
+
+/**
+ * Results of a mail server settings lookup.
+ */
+sealed interface AutoDiscoveryResult {
+    /**
+     * Mail server settings found during the lookup.
+     */
+    data class Settings(
+        val incomingServerSettings: IncomingServerSettings,
+        val outgoingServerSettings: OutgoingServerSettings,
+
+        /**
+         * Indicates whether the mail server settings lookup was using only trusted channels.
+         *
+         * `true` if the settings lookup was only using trusted channels, e.g. lookup via HTTPS where the server
+         * presented a trusted certificate. `false´ otherwise.
+         *
+         * IMPORTANT: When this value is `false`, the settings should be presented to the user and only be used after
+         * the user has given consent.
+         */
+        val isTrusted: Boolean,
+
+        /**
+         * String describing the source of the server settings. Use a URI if possible.
+         */
+        val source: String,
+    ) : AutoDiscoveryResult
+
+    /**
+     * No usable mail server settings were found.
+     */
+    object NoUsableSettingsFound : AutoDiscoveryResult
+
+    /**
+     * A network error occurred while looking for mail server settings.
+     */
+    data class NetworkError(val exception: IOException) : AutoDiscoveryResult
+
+    /**
+     * Encountered an unexpected exception when looking up mail server settings.
+     */
+    data class UnexpectedException(val exception: Exception) : AutoDiscoveryResult
+}
+
+/**
+ * Incoming mail server settings.
+ *
+ * Implementations contain protocol-specific properties.
+ */
+interface IncomingServerSettings
+
+/**
+ * Outgoing mail server settings.
+ *
+ * Implementations contain protocol-specific properties.
+ */
+interface OutgoingServerSettings
diff --git a/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/AutoDiscoveryRunnable.kt b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/AutoDiscoveryRunnable.kt
new file mode 100644
index 0000000000000000000000000000000000000000..b7b592c07af42ef9f79b2793154201cdaac03ca8
--- /dev/null
+++ b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/AutoDiscoveryRunnable.kt
@@ -0,0 +1,10 @@
+package app.k9mail.autodiscovery.api
+
+/**
+ * Performs a mail server settings lookup.
+ *
+ * This is an abstraction that allows us to run multiple lookups in parallel.
+ */
+fun interface AutoDiscoveryRunnable {
+    suspend fun run(): AutoDiscoveryResult
+}
diff --git a/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/AutoDiscoveryService.kt b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/AutoDiscoveryService.kt
new file mode 100644
index 0000000000000000000000000000000000000000..70283c61d66c58d8dbc4ecbc6fc7737afc12c9b3
--- /dev/null
+++ b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/AutoDiscoveryService.kt
@@ -0,0 +1,10 @@
+package app.k9mail.autodiscovery.api
+
+import app.k9mail.core.common.mail.EmailAddress
+
+/**
+ * Tries to find mail server settings for a given email address.
+ */
+interface AutoDiscoveryService {
+    suspend fun discover(email: EmailAddress): AutoDiscoveryResult
+}
diff --git a/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/ConnectionSecurity.kt b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/ConnectionSecurity.kt
new file mode 100644
index 0000000000000000000000000000000000000000..ffe299a79fe08ba6f994fe732daa5f58b42a4b0d
--- /dev/null
+++ b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/ConnectionSecurity.kt
@@ -0,0 +1,9 @@
+package app.k9mail.autodiscovery.api
+
+/**
+ * The connection security methods supported when using the [AutoDiscovery] mechanism.
+ */
+enum class ConnectionSecurity {
+    StartTLS,
+    TLS,
+}
diff --git a/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/ConnectionSettingsDiscovery.kt b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/ConnectionSettingsDiscovery.kt
index f74362bf6c11c525257415fd38b187553c16c9d4..dc2e40fc8c6cd13d02f536ec1585d71a5aa4a3bc 100644
--- a/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/ConnectionSettingsDiscovery.kt
+++ b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/ConnectionSettingsDiscovery.kt
@@ -3,6 +3,7 @@ package app.k9mail.autodiscovery.api
 import com.fsck.k9.mail.AuthType
 import com.fsck.k9.mail.ConnectionSecurity
 
+@Deprecated("New code should use app.k9mail.autodiscovery.api.AutoDiscovery")
 interface ConnectionSettingsDiscovery {
     fun discover(email: String): DiscoveryResults?
 }
diff --git a/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/ImapServerSettings.kt b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/ImapServerSettings.kt
new file mode 100644
index 0000000000000000000000000000000000000000..0184fe826ccb5a193ff32a2f1668fbee3e60902a
--- /dev/null
+++ b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/ImapServerSettings.kt
@@ -0,0 +1,12 @@
+package app.k9mail.autodiscovery.api
+
+import app.k9mail.core.common.net.Hostname
+import app.k9mail.core.common.net.Port
+
+data class ImapServerSettings(
+    val hostname: Hostname,
+    val port: Port,
+    val connectionSecurity: ConnectionSecurity,
+    val authenticationTypes: List<AuthenticationType>,
+    val username: String,
+) : IncomingServerSettings
diff --git a/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/SmtpServerSettings.kt b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/SmtpServerSettings.kt
new file mode 100644
index 0000000000000000000000000000000000000000..ea430a381d2c82c258c431de63e7595937399f60
--- /dev/null
+++ b/feature/autodiscovery/api/src/main/kotlin/app/k9mail/autodiscovery/api/SmtpServerSettings.kt
@@ -0,0 +1,12 @@
+package app.k9mail.autodiscovery.api
+
+import app.k9mail.core.common.net.Hostname
+import app.k9mail.core.common.net.Port
+
+data class SmtpServerSettings(
+    val hostname: Hostname,
+    val port: Port,
+    val connectionSecurity: ConnectionSecurity,
+    val authenticationTypes: List<AuthenticationType>,
+    val username: String,
+) : OutgoingServerSettings
diff --git a/feature/autodiscovery/autoconfig/build.gradle.kts b/feature/autodiscovery/autoconfig/build.gradle.kts
index cebc3c662d874290c582073b58b73ced9d3bd829..7a2ff5fe1a3f55e1fab551a5cd3485596c6b9b9b 100644
--- a/feature/autodiscovery/autoconfig/build.gradle.kts
+++ b/feature/autodiscovery/autoconfig/build.gradle.kts
@@ -5,10 +5,14 @@ plugins {
 
 dependencies {
     api(projects.feature.autodiscovery.api)
+    api(libs.okhttp)
 
+    implementation(libs.kotlinx.coroutines.core)
+    implementation(libs.minidns.hla)
     compileOnly(libs.xmlpull)
-    implementation(libs.okhttp)
 
+    testImplementation(libs.kotlinx.coroutines.test)
     testImplementation(libs.kxml2)
+    testImplementation(libs.jsoup)
     testImplementation(libs.okhttp.mockwebserver)
 }
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigDiscovery.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigDiscovery.kt
index e6a3d53e02c13cca0edc8ce69e0a31fc88572fd2..61427957a8f9ed847cda55bf57f732519b47fba0 100644
--- a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigDiscovery.kt
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigDiscovery.kt
@@ -1,28 +1,49 @@
 package app.k9mail.autodiscovery.autoconfig
 
-import app.k9mail.autodiscovery.api.ConnectionSettingsDiscovery
-import app.k9mail.autodiscovery.api.DiscoveryResults
+import app.k9mail.autodiscovery.api.AutoDiscovery
+import app.k9mail.autodiscovery.api.AutoDiscoveryRunnable
+import app.k9mail.core.common.mail.EmailAddress
+import app.k9mail.core.common.mail.toDomain
+import okhttp3.OkHttpClient
 
-class AutoconfigDiscovery(
+class AutoconfigDiscovery internal constructor(
     private val urlProvider: AutoconfigUrlProvider,
-    private val fetcher: AutoconfigFetcher,
-    private val parser: AutoconfigParser,
-) : ConnectionSettingsDiscovery {
-
-    override fun discover(email: String): DiscoveryResults? {
-        val autoconfigUrls = urlProvider.getAutoconfigUrls(email)
-
-        return autoconfigUrls
-            .asSequence()
-            .mapNotNull { autoconfigUrl ->
-                fetcher.fetchAutoconfigFile(autoconfigUrl)?.use { inputStream ->
-                    parser.parseSettings(inputStream, email)
-                }
-            }
-            .firstOrNull { result ->
-                result.incoming.isNotEmpty() || result.outgoing.isNotEmpty()
+    private val autoconfigFetcher: AutoconfigFetcher,
+) : AutoDiscovery {
+
+    override fun initDiscovery(email: EmailAddress): List<AutoDiscoveryRunnable> {
+        val domain = email.domain.toDomain()
+
+        val autoconfigUrls = urlProvider.getAutoconfigUrls(domain, email)
+
+        return autoconfigUrls.map { autoconfigUrl ->
+            AutoDiscoveryRunnable {
+                autoconfigFetcher.fetchAutoconfig(autoconfigUrl, email)
             }
+        }
     }
+}
+
+fun createProviderAutoconfigDiscovery(
+    okHttpClient: OkHttpClient,
+    config: AutoconfigUrlConfig,
+): AutoconfigDiscovery {
+    val urlProvider = ProviderAutoconfigUrlProvider(config)
+    return createAutoconfigDiscovery(okHttpClient, urlProvider)
+}
+
+fun createIspDbAutoconfigDiscovery(okHttpClient: OkHttpClient): AutoconfigDiscovery {
+    val urlProvider = IspDbAutoconfigUrlProvider()
+    return createAutoconfigDiscovery(okHttpClient, urlProvider)
+}
 
-    override fun toString(): String = "Thunderbird autoconfig"
+private fun createAutoconfigDiscovery(
+    okHttpClient: OkHttpClient,
+    urlProvider: AutoconfigUrlProvider,
+): AutoconfigDiscovery {
+    val autoconfigFetcher = RealAutoconfigFetcher(
+        fetcher = OkHttpFetcher(okHttpClient),
+        parser = SuspendableAutoconfigParser(RealAutoconfigParser()),
+    )
+    return AutoconfigDiscovery(urlProvider, autoconfigFetcher)
 }
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigFetcher.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigFetcher.kt
index 4a510c709346d98a671187a70f2ed1cabb3148fb..6db8f6b9d0827c95d8c2d1022d6adcb35a8261c4 100644
--- a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigFetcher.kt
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigFetcher.kt
@@ -1,28 +1,12 @@
 package app.k9mail.autodiscovery.autoconfig
 
-import com.fsck.k9.logging.Timber
-import java.io.IOException
-import java.io.InputStream
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.core.common.mail.EmailAddress
 import okhttp3.HttpUrl
-import okhttp3.OkHttpClient
-import okhttp3.Request
 
-class AutoconfigFetcher(private val okHttpClient: OkHttpClient) {
-
-    fun fetchAutoconfigFile(url: HttpUrl): InputStream? {
-        return try {
-            val request = Request.Builder().url(url).build()
-
-            val response = okHttpClient.newCall(request).execute()
-
-            if (response.isSuccessful) {
-                response.body?.byteStream()
-            } else {
-                null
-            }
-        } catch (e: IOException) {
-            Timber.d(e, "Error fetching URL: %s", url)
-            null
-        }
-    }
+/**
+ * Fetches and parses Autoconfig settings.
+ */
+internal interface AutoconfigFetcher {
+    suspend fun fetchAutoconfig(autoconfigUrl: HttpUrl, email: EmailAddress): AutoDiscoveryResult
 }
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigParser.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigParser.kt
index c57bca062d176d73e574eaf3798cf059dfedbc37..51079585914eb0988d73e699f13d251b22371594 100644
--- a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigParser.kt
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigParser.kt
@@ -1,102 +1,13 @@
 package app.k9mail.autodiscovery.autoconfig
 
-import app.k9mail.autodiscovery.api.DiscoveredServerSettings
-import app.k9mail.autodiscovery.api.DiscoveryResults
-import com.fsck.k9.mail.AuthType
-import com.fsck.k9.mail.ConnectionSecurity
-import java.io.IOException
+import app.k9mail.core.common.mail.EmailAddress
 import java.io.InputStream
-import java.io.InputStreamReader
-import org.xmlpull.v1.XmlPullParser
-import org.xmlpull.v1.XmlPullParserException
-import org.xmlpull.v1.XmlPullParserFactory
 
 /**
- * Parser for Thunderbird's
- * [Autoconfig file format](https://wiki.mozilla.org/Thunderbird:Autoconfiguration:ConfigFileFormat)
+ * Parser for Thunderbird's Autoconfig file format.
+ *
+ * See [https://github.com/thundernest/autoconfig](https://github.com/thundernest/autoconfig)
  */
-class AutoconfigParser {
-    fun parseSettings(stream: InputStream, email: String): DiscoveryResults? {
-        val factory = XmlPullParserFactory.newInstance()
-        val xpp = factory.newPullParser()
-
-        xpp.setInput(InputStreamReader(stream))
-
-        val incomingServers = mutableListOf<DiscoveredServerSettings>()
-        val outgoingServers = mutableListOf<DiscoveredServerSettings>()
-        var eventType = xpp.eventType
-        while (eventType != XmlPullParser.END_DOCUMENT) {
-            if (eventType == XmlPullParser.START_TAG) {
-                when (xpp.name) {
-                    "incomingServer" -> {
-                        incomingServers += parseServer(xpp, "incomingServer", email)
-                    }
-                    "outgoingServer" -> {
-                        outgoingServers += parseServer(xpp, "outgoingServer", email)
-                    }
-                }
-            }
-            eventType = xpp.next()
-        }
-        return DiscoveryResults(incomingServers, outgoingServers)
-    }
-
-    private fun parseServer(xpp: XmlPullParser, nodeName: String, email: String): DiscoveredServerSettings {
-        val type = xpp.getAttributeValue(null, "type")
-        var host: String? = null
-        var username: String? = null
-        var port: Int? = null
-        var authType: AuthType? = null
-        var connectionSecurity: ConnectionSecurity? = null
-
-        var eventType = xpp.eventType
-        while (!(eventType == XmlPullParser.END_TAG && nodeName == xpp.name)) {
-            if (eventType == XmlPullParser.START_TAG) {
-                when (xpp.name) {
-                    "hostname" -> {
-                        host = getText(xpp)
-                    }
-                    "port" -> {
-                        port = getText(xpp).toInt()
-                    }
-                    "username" -> {
-                        username = getText(xpp).replace("%EMAILADDRESS%", email)
-                    }
-                    "authentication" -> {
-                        if (authType == null) authType = parseAuthType(getText(xpp))
-                    }
-                    "socketType" -> {
-                        connectionSecurity = parseSocketType(getText(xpp))
-                    }
-                }
-            }
-            eventType = xpp.next()
-        }
-
-        return DiscoveredServerSettings(type, host!!, port!!, connectionSecurity!!, authType, username)
-    }
-
-    private fun parseAuthType(authentication: String): AuthType? {
-        return when (authentication) {
-            "password-cleartext" -> AuthType.PLAIN
-            "TLS-client-cert" -> AuthType.EXTERNAL
-            "secure" -> AuthType.CRAM_MD5
-            else -> null
-        }
-    }
-
-    private fun parseSocketType(socketType: String): ConnectionSecurity? {
-        return when (socketType) {
-            "plain" -> ConnectionSecurity.NONE
-            "SSL" -> ConnectionSecurity.SSL_TLS_REQUIRED
-            "STARTTLS" -> ConnectionSecurity.STARTTLS_REQUIRED
-            else -> null
-        }
-    }
-
-    @Throws(XmlPullParserException::class, IOException::class)
-    private fun getText(xpp: XmlPullParser): String {
-        val eventType = xpp.next()
-        return if (eventType != XmlPullParser.TEXT) "" else xpp.text
-    }
+internal interface AutoconfigParser {
+    fun parseSettings(inputStream: InputStream, email: EmailAddress): AutoconfigParserResult
 }
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigParserException.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigParserException.kt
new file mode 100644
index 0000000000000000000000000000000000000000..0009c6bcf95a194d54a209337f2c5b7d1c03a057
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigParserException.kt
@@ -0,0 +1,3 @@
+package app.k9mail.autodiscovery.autoconfig
+
+class AutoconfigParserException(message: String, cause: Throwable? = null) : RuntimeException(message, cause)
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigParserResult.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigParserResult.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d82caefecc5b320545b6161dd006b916c4f9a9fe
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigParserResult.kt
@@ -0,0 +1,22 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.autodiscovery.api.IncomingServerSettings
+import app.k9mail.autodiscovery.api.OutgoingServerSettings
+
+/**
+ * Result type for [AutoconfigParser].
+ */
+internal sealed interface AutoconfigParserResult {
+    /**
+     * Server settings extracted from the Autoconfig XML.
+     */
+    data class Settings(
+        val incomingServerSettings: IncomingServerSettings,
+        val outgoingServerSettings: OutgoingServerSettings,
+    ) : AutoconfigParserResult
+
+    /**
+     * Server settings couldn't be extracted.
+     */
+    data class ParserError(val error: AutoconfigParserException) : AutoconfigParserResult
+}
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigUrlProvider.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigUrlProvider.kt
index 94b3451ad333b6cf0d54422141a638a9d1c185a9..63ddafa094ecc305b803911b360a13520d0eeb5f 100644
--- a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigUrlProvider.kt
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigUrlProvider.kt
@@ -1,7 +1,9 @@
 package app.k9mail.autodiscovery.autoconfig
 
+import app.k9mail.core.common.mail.EmailAddress
+import app.k9mail.core.common.net.Domain
 import okhttp3.HttpUrl
 
-interface AutoconfigUrlProvider {
-    fun getAutoconfigUrls(email: String): List<HttpUrl>
+internal interface AutoconfigUrlProvider {
+    fun getAutoconfigUrls(domain: Domain, email: EmailAddress? = null): List<HttpUrl>
 }
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/BaseDomainExtractor.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/BaseDomainExtractor.kt
new file mode 100644
index 0000000000000000000000000000000000000000..ac1f632036e7b6ac3f8500869419c9c43f2c5194
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/BaseDomainExtractor.kt
@@ -0,0 +1,12 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.core.common.net.Domain
+
+/**
+ * Extract the base domain from a host name.
+ *
+ * An implementation needs to respect the [Public Suffix List](https://publicsuffix.org/).
+ */
+internal interface BaseDomainExtractor {
+    fun extractBaseDomain(domain: Domain): Domain
+}
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/HttpFetchResult.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/HttpFetchResult.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c793225513db413e4d8e384345720e2f0035d0f3
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/HttpFetchResult.kt
@@ -0,0 +1,26 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import java.io.InputStream
+
+/**
+ * Result type for [HttpFetcher].
+ */
+internal sealed interface HttpFetchResult {
+    /**
+     * The HTTP request returned a success response.
+     *
+     * @param inputStream Contains the response body.
+     * @param isTrusted `true` iff all associated requests were using HTTPS with a trusted certificate.
+     */
+    data class SuccessResponse(
+        val inputStream: InputStream,
+        val isTrusted: Boolean,
+    ) : HttpFetchResult
+
+    /**
+     * The server returned an error response.
+     *
+     * @param code The HTTP status code.
+     */
+    data class ErrorResponse(val code: Int) : HttpFetchResult
+}
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/HttpFetcher.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/HttpFetcher.kt
new file mode 100644
index 0000000000000000000000000000000000000000..66cd98c3c50efe84f3fb018336ac61ac7b79beae
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/HttpFetcher.kt
@@ -0,0 +1,7 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import okhttp3.HttpUrl
+
+internal interface HttpFetcher {
+    suspend fun fetch(url: HttpUrl): HttpFetchResult
+}
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/IspDbAutoconfigUrlProvider.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/IspDbAutoconfigUrlProvider.kt
index e5ce650ce19bf5a41d7678b1c19fabd50426ef27..3217e31fa7a3789551baeeff46728df53d29bd38 100644
--- a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/IspDbAutoconfigUrlProvider.kt
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/IspDbAutoconfigUrlProvider.kt
@@ -1,22 +1,20 @@
 package app.k9mail.autodiscovery.autoconfig
 
-import com.fsck.k9.helper.EmailHelper
+import app.k9mail.core.common.mail.EmailAddress
+import app.k9mail.core.common.net.Domain
 import okhttp3.HttpUrl
 import okhttp3.HttpUrl.Companion.toHttpUrl
 
-class IspDbAutoconfigUrlProvider : AutoconfigUrlProvider {
-    override fun getAutoconfigUrls(email: String): List<HttpUrl> {
-        val domain = EmailHelper.getDomainFromEmailAddress(email)
-        requireNotNull(domain) { "Couldn't extract domain from email address: $email" }
-
+internal class IspDbAutoconfigUrlProvider : AutoconfigUrlProvider {
+    override fun getAutoconfigUrls(domain: Domain, email: EmailAddress?): List<HttpUrl> {
         return listOf(createIspDbUrl(domain))
     }
 
-    private fun createIspDbUrl(domain: String): HttpUrl {
+    private fun createIspDbUrl(domain: Domain): HttpUrl {
         // https://autoconfig.thunderbird.net/v1.1/{domain}
         return "https://autoconfig.thunderbird.net/v1.1/".toHttpUrl()
             .newBuilder()
-            .addPathSegment(domain)
+            .addPathSegment(domain.value)
             .build()
     }
 }
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/MiniDnsMxResolver.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/MiniDnsMxResolver.kt
new file mode 100644
index 0000000000000000000000000000000000000000..10b44c6718499f96f1efaa4728ea112cbffb8259
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/MiniDnsMxResolver.kt
@@ -0,0 +1,21 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.core.common.net.Domain
+import app.k9mail.core.common.net.toDomain
+import org.minidns.hla.ResolverApi
+import org.minidns.record.MX
+
+internal class MiniDnsMxResolver : MxResolver {
+    override fun lookup(domain: Domain): MxLookupResult {
+        val result = ResolverApi.INSTANCE.resolve(domain.value, MX::class.java)
+
+        val mxNames = result.answersOrEmptySet
+            .sortedBy { it.priority }
+            .map { it.target.toString().toDomain() }
+
+        return MxLookupResult(
+            mxNames = mxNames,
+            isTrusted = if (result.wasSuccessful()) result.isAuthenticData else false,
+        )
+    }
+}
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/MxLookupAutoconfigDiscovery.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/MxLookupAutoconfigDiscovery.kt
new file mode 100644
index 0000000000000000000000000000000000000000..55521c6ee1c7230f80bc4fd0d197436ef34a4113
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/MxLookupAutoconfigDiscovery.kt
@@ -0,0 +1,97 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.autodiscovery.api.AutoDiscovery
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult.NoUsableSettingsFound
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult.Settings
+import app.k9mail.autodiscovery.api.AutoDiscoveryRunnable
+import app.k9mail.core.common.mail.EmailAddress
+import app.k9mail.core.common.mail.toDomain
+import app.k9mail.core.common.net.Domain
+import com.fsck.k9.logging.Timber
+import java.io.IOException
+import okhttp3.OkHttpClient
+
+class MxLookupAutoconfigDiscovery internal constructor(
+    private val mxResolver: SuspendableMxResolver,
+    private val baseDomainExtractor: BaseDomainExtractor,
+    private val subDomainExtractor: SubDomainExtractor,
+    private val urlProvider: AutoconfigUrlProvider,
+    private val autoconfigFetcher: AutoconfigFetcher,
+) : AutoDiscovery {
+
+    override fun initDiscovery(email: EmailAddress): List<AutoDiscoveryRunnable> {
+        return listOf(
+            AutoDiscoveryRunnable {
+                mxLookupAutoconfig(email)
+            },
+        )
+    }
+
+    @Suppress("ReturnCount")
+    private suspend fun mxLookupAutoconfig(email: EmailAddress): AutoDiscoveryResult {
+        val domain = email.domain.toDomain()
+
+        val mxLookupResult = mxLookup(domain) ?: return NoUsableSettingsFound
+        val mxHostName = mxLookupResult.mxNames.first()
+
+        val mxBaseDomain = getMxBaseDomain(mxHostName)
+        if (mxBaseDomain == domain) {
+            // Exit early to match Thunderbird's behavior.
+            return NoUsableSettingsFound
+        }
+
+        // In addition to just the base domain, also check the MX hostname without the first label to differentiate
+        // between Outlook.com/Hotmail and Office365 business domains.
+        val mxSubDomain = getNextSubDomain(mxHostName)?.takeIf { it != mxBaseDomain }
+
+        var latestResult: AutoDiscoveryResult = NoUsableSettingsFound
+        for (domainToCheck in listOfNotNull(mxSubDomain, mxBaseDomain)) {
+            for (autoconfigUrl in urlProvider.getAutoconfigUrls(domainToCheck)) {
+                val discoveryResult = autoconfigFetcher.fetchAutoconfig(autoconfigUrl, email)
+                if (discoveryResult is Settings) {
+                    return discoveryResult.copy(
+                        isTrusted = mxLookupResult.isTrusted && discoveryResult.isTrusted,
+                    )
+                }
+
+                latestResult = discoveryResult
+            }
+        }
+
+        return latestResult
+    }
+
+    private suspend fun mxLookup(domain: Domain): MxLookupResult? {
+        // Only return the most preferred entry to match Thunderbird's behavior.
+        return try {
+            mxResolver.lookup(domain).takeIf { it.mxNames.isNotEmpty() }
+        } catch (e: IOException) {
+            Timber.d(e, "Failed to get MX record for domain: %s", domain.value)
+            null
+        }
+    }
+
+    private fun getMxBaseDomain(mxHostName: Domain): Domain {
+        return baseDomainExtractor.extractBaseDomain(mxHostName)
+    }
+
+    private fun getNextSubDomain(domain: Domain): Domain? {
+        return subDomainExtractor.extractSubDomain(domain)
+    }
+}
+
+fun createMxLookupAutoconfigDiscovery(okHttpClient: OkHttpClient): MxLookupAutoconfigDiscovery {
+    val baseDomainExtractor = OkHttpBaseDomainExtractor()
+    val autoconfigFetcher = RealAutoconfigFetcher(
+        fetcher = OkHttpFetcher(okHttpClient),
+        parser = SuspendableAutoconfigParser(RealAutoconfigParser()),
+    )
+    return MxLookupAutoconfigDiscovery(
+        mxResolver = SuspendableMxResolver(MiniDnsMxResolver()),
+        baseDomainExtractor = baseDomainExtractor,
+        subDomainExtractor = RealSubDomainExtractor(baseDomainExtractor),
+        urlProvider = IspDbAutoconfigUrlProvider(),
+        autoconfigFetcher = autoconfigFetcher,
+    )
+}
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/MxLookupResult.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/MxLookupResult.kt
new file mode 100644
index 0000000000000000000000000000000000000000..772668907ac88bb93d1e9c3068da77723fe28d0f
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/MxLookupResult.kt
@@ -0,0 +1,14 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.core.common.net.Domain
+
+/**
+ * Result for [MxResolver].
+ *
+ * @param mxNames The hostnames from the MX records.
+ * @param isTrusted `true` iff the results were properly signed (DNSSEC) or were retrieved using a secure channel.
+ */
+data class MxLookupResult(
+    val mxNames: List<Domain>,
+    val isTrusted: Boolean,
+)
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/MxResolver.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/MxResolver.kt
new file mode 100644
index 0000000000000000000000000000000000000000..921017b83117bacd307a716984c336a5f9df64e4
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/MxResolver.kt
@@ -0,0 +1,10 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.core.common.net.Domain
+
+/**
+ * Look up MX records for a domain.
+ */
+internal interface MxResolver {
+    fun lookup(domain: Domain): MxLookupResult
+}
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/OkHttpBaseDomainExtractor.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/OkHttpBaseDomainExtractor.kt
new file mode 100644
index 0000000000000000000000000000000000000000..9bd89e49b61b8a3bc6b10ca834fcc5932814c8ae
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/OkHttpBaseDomainExtractor.kt
@@ -0,0 +1,18 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.core.common.net.Domain
+import app.k9mail.core.common.net.toDomain
+import okhttp3.HttpUrl
+
+internal class OkHttpBaseDomainExtractor : BaseDomainExtractor {
+    override fun extractBaseDomain(domain: Domain): Domain {
+        return domain.value.toHttpUrlOrNull().topPrivateDomain()?.toDomain() ?: domain
+    }
+
+    private fun String.toHttpUrlOrNull(): HttpUrl {
+        return HttpUrl.Builder()
+            .scheme("https")
+            .host(this)
+            .build()
+    }
+}
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/OkHttpFetcher.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/OkHttpFetcher.kt
new file mode 100644
index 0000000000000000000000000000000000000000..1526b8b90424276f8d10234745b70e13bbd7e115
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/OkHttpFetcher.kt
@@ -0,0 +1,63 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import java.io.IOException
+import kotlin.coroutines.resume
+import kotlinx.coroutines.suspendCancellableCoroutine
+import okhttp3.Call
+import okhttp3.Callback
+import okhttp3.HttpUrl
+import okhttp3.OkHttpClient
+import okhttp3.Request.Builder
+import okhttp3.Response
+
+internal class OkHttpFetcher(
+    private val okHttpClient: OkHttpClient,
+) : HttpFetcher {
+
+    override suspend fun fetch(url: HttpUrl): HttpFetchResult {
+        return suspendCancellableCoroutine { cancellableContinuation ->
+            val request = Builder()
+                .url(url)
+                .build()
+
+            val call = okHttpClient.newCall(request)
+
+            cancellableContinuation.invokeOnCancellation {
+                call.cancel()
+            }
+
+            val responseCallback = object : Callback {
+                override fun onFailure(call: Call, e: IOException) {
+                    cancellableContinuation.cancel(e)
+                }
+
+                override fun onResponse(call: Call, response: Response) {
+                    if (response.isSuccessful) {
+                        val result = HttpFetchResult.SuccessResponse(
+                            inputStream = response.body!!.byteStream(),
+                            isTrusted = response.isTrusted(),
+                        )
+                        cancellableContinuation.resume(result)
+                    } else {
+                        // We don't care about the body of error responses.
+                        response.close()
+
+                        val result = HttpFetchResult.ErrorResponse(response.code)
+                        cancellableContinuation.resume(result)
+                    }
+                }
+            }
+
+            call.enqueue(responseCallback)
+        }
+    }
+
+    private tailrec fun Response.isTrusted(): Boolean {
+        val priorResponse = priorResponse
+        return when {
+            !request.isHttps -> false
+            priorResponse == null -> true
+            else -> priorResponse.isTrusted()
+        }
+    }
+}
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/ProviderAutoconfigUrlProvider.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/ProviderAutoconfigUrlProvider.kt
index 1f4be940cbda10b007c8dde191db951320d90dd3..664f4b351eee1c9b1b26738cf962cab887df88d4 100644
--- a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/ProviderAutoconfigUrlProvider.kt
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/ProviderAutoconfigUrlProvider.kt
@@ -1,13 +1,11 @@
 package app.k9mail.autodiscovery.autoconfig
 
-import com.fsck.k9.helper.EmailHelper
+import app.k9mail.core.common.mail.EmailAddress
+import app.k9mail.core.common.net.Domain
 import okhttp3.HttpUrl
 
-class ProviderAutoconfigUrlProvider(private val config: AutoconfigUrlConfig) : AutoconfigUrlProvider {
-    override fun getAutoconfigUrls(email: String): List<HttpUrl> {
-        val domain = EmailHelper.getDomainFromEmailAddress(email)
-        requireNotNull(domain) { "Couldn't extract domain from email address: $email" }
-
+internal class ProviderAutoconfigUrlProvider(private val config: AutoconfigUrlConfig) : AutoconfigUrlProvider {
+    override fun getAutoconfigUrls(domain: Domain, email: EmailAddress?): List<HttpUrl> {
         return buildList {
             add(createProviderUrl(domain, email, useHttps = true))
             add(createDomainUrl(domain, email, useHttps = true))
@@ -19,31 +17,31 @@ class ProviderAutoconfigUrlProvider(private val config: AutoconfigUrlConfig) : A
         }
     }
 
-    private fun createProviderUrl(domain: String, email: String, useHttps: Boolean): HttpUrl {
+    private fun createProviderUrl(domain: Domain, email: EmailAddress?, useHttps: Boolean): HttpUrl {
         // https://autoconfig.{domain}/mail/config-v1.1.xml?emailaddress={email}
         // http://autoconfig.{domain}/mail/config-v1.1.xml?emailaddress={email}
         return HttpUrl.Builder()
             .scheme(if (useHttps) "https" else "http")
-            .host("autoconfig.$domain")
+            .host("autoconfig.${domain.value}")
             .addEncodedPathSegments("mail/config-v1.1.xml")
             .apply {
-                if (config.includeEmailAddress) {
-                    addQueryParameter("emailaddress", email)
+                if (email != null && config.includeEmailAddress) {
+                    addQueryParameter("emailaddress", email.address)
                 }
             }
             .build()
     }
 
-    private fun createDomainUrl(domain: String, email: String, useHttps: Boolean): HttpUrl {
+    private fun createDomainUrl(domain: Domain, email: EmailAddress?, useHttps: Boolean): HttpUrl {
         // https://{domain}/.well-known/autoconfig/mail/config-v1.1.xml?emailaddress={email}
         // http://{domain}/.well-known/autoconfig/mail/config-v1.1.xml?emailaddress={email}
         return HttpUrl.Builder()
             .scheme(if (useHttps) "https" else "http")
-            .host(domain)
+            .host(domain.value)
             .addEncodedPathSegments(".well-known/autoconfig/mail/config-v1.1.xml")
             .apply {
-                if (config.includeEmailAddress) {
-                    addQueryParameter("emailaddress", email)
+                if (email != null && config.includeEmailAddress) {
+                    addQueryParameter("emailaddress", email.address)
                 }
             }
             .build()
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/RealAutoconfigFetcher.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/RealAutoconfigFetcher.kt
new file mode 100644
index 0000000000000000000000000000000000000000..e43ece464ae642e5405a528abd445c135c81ecab
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/RealAutoconfigFetcher.kt
@@ -0,0 +1,56 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.autodiscovery.autoconfig.AutoconfigParserResult.ParserError
+import app.k9mail.autodiscovery.autoconfig.AutoconfigParserResult.Settings
+import app.k9mail.autodiscovery.autoconfig.HttpFetchResult.ErrorResponse
+import app.k9mail.autodiscovery.autoconfig.HttpFetchResult.SuccessResponse
+import app.k9mail.core.common.mail.EmailAddress
+import com.fsck.k9.logging.Timber
+import java.io.IOException
+import okhttp3.HttpUrl
+
+internal class RealAutoconfigFetcher(
+    private val fetcher: HttpFetcher,
+    private val parser: SuspendableAutoconfigParser,
+) : AutoconfigFetcher {
+    override suspend fun fetchAutoconfig(autoconfigUrl: HttpUrl, email: EmailAddress): AutoDiscoveryResult {
+        return try {
+            when (val fetchResult = fetcher.fetch(autoconfigUrl)) {
+                is SuccessResponse -> {
+                    parseSettings(fetchResult, email, autoconfigUrl)
+                }
+                is ErrorResponse -> AutoDiscoveryResult.NoUsableSettingsFound
+            }
+        } catch (e: IOException) {
+            Timber.d(e, "Error fetching Autoconfig from URL: %s", autoconfigUrl)
+            AutoDiscoveryResult.NetworkError(e)
+        }
+    }
+
+    private suspend fun parseSettings(
+        fetchResult: SuccessResponse,
+        email: EmailAddress,
+        autoconfigUrl: HttpUrl,
+    ): AutoDiscoveryResult {
+        return try {
+            fetchResult.inputStream.use { inputStream ->
+                return when (val parserResult = parser.parseSettings(inputStream, email)) {
+                    is Settings -> {
+                        AutoDiscoveryResult.Settings(
+                            incomingServerSettings = parserResult.incomingServerSettings,
+                            outgoingServerSettings = parserResult.outgoingServerSettings,
+                            isTrusted = fetchResult.isTrusted,
+                            source = autoconfigUrl.toString(),
+                        )
+                    }
+
+                    is ParserError -> AutoDiscoveryResult.NoUsableSettingsFound
+                }
+            }
+        } catch (e: AutoconfigParserException) {
+            Timber.d(e, "Failed to parse config from URL: %s", autoconfigUrl)
+            AutoDiscoveryResult.NoUsableSettingsFound
+        }
+    }
+}
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/RealAutoconfigParser.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/RealAutoconfigParser.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c8f8e04c056e9760acc378c11dda8b8fc1324002
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/RealAutoconfigParser.kt
@@ -0,0 +1,318 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.autodiscovery.api.AuthenticationType
+import app.k9mail.autodiscovery.api.AuthenticationType.OAuth2
+import app.k9mail.autodiscovery.api.AuthenticationType.PasswordCleartext
+import app.k9mail.autodiscovery.api.AuthenticationType.PasswordEncrypted
+import app.k9mail.autodiscovery.api.ConnectionSecurity
+import app.k9mail.autodiscovery.api.ConnectionSecurity.StartTLS
+import app.k9mail.autodiscovery.api.ConnectionSecurity.TLS
+import app.k9mail.autodiscovery.api.ImapServerSettings
+import app.k9mail.autodiscovery.api.IncomingServerSettings
+import app.k9mail.autodiscovery.api.OutgoingServerSettings
+import app.k9mail.autodiscovery.api.SmtpServerSettings
+import app.k9mail.core.common.mail.EmailAddress
+import app.k9mail.core.common.net.HostNameUtils
+import app.k9mail.core.common.net.Hostname
+import app.k9mail.core.common.net.Port
+import app.k9mail.core.common.net.toHostname
+import app.k9mail.core.common.net.toPort
+import com.fsck.k9.logging.Timber
+import java.io.InputStream
+import java.io.InputStreamReader
+import org.xmlpull.v1.XmlPullParser
+import org.xmlpull.v1.XmlPullParserException
+import org.xmlpull.v1.XmlPullParserFactory
+
+private typealias ServerSettingsFactory<T> = (
+    hostname: Hostname,
+    port: Port,
+    connectionSecurity: ConnectionSecurity,
+    authenticationTypes: List<AuthenticationType>,
+    username: String,
+) -> T
+
+internal class RealAutoconfigParser : AutoconfigParser {
+    override fun parseSettings(inputStream: InputStream, email: EmailAddress): AutoconfigParserResult {
+        return try {
+            ClientConfigParser(inputStream, email).parse()
+        } catch (e: XmlPullParserException) {
+            AutoconfigParserResult.ParserError(error = AutoconfigParserException("Error parsing Autoconfig XML", e))
+        } catch (e: AutoconfigParserException) {
+            AutoconfigParserResult.ParserError(e)
+        }
+    }
+}
+
+@Suppress("TooManyFunctions")
+private class ClientConfigParser(
+    private val inputStream: InputStream,
+    private val email: EmailAddress,
+) {
+    private val localPart = email.localPart
+    private val domain = email.domain.normalized
+
+    private val pullParser: XmlPullParser = XmlPullParserFactory.newInstance().newPullParser().apply {
+        setInput(InputStreamReader(inputStream))
+    }
+
+    fun parse(): AutoconfigParserResult {
+        var result: AutoconfigParserResult? = null
+        do {
+            val eventType = pullParser.next()
+
+            if (eventType == XmlPullParser.START_TAG) {
+                when (pullParser.name) {
+                    "clientConfig" -> {
+                        result = parseClientConfig()
+                    }
+                    else -> skipElement()
+                }
+            }
+        } while (eventType != XmlPullParser.END_DOCUMENT)
+
+        if (result == null) {
+            parserError("Missing 'clientConfig' element")
+        }
+
+        return result
+    }
+
+    private fun parseClientConfig(): AutoconfigParserResult {
+        var result: AutoconfigParserResult? = null
+
+        readElement { eventType ->
+            if (eventType == XmlPullParser.START_TAG) {
+                when (pullParser.name) {
+                    "emailProvider" -> {
+                        result = parseEmailProvider()
+                    }
+                    else -> skipElement()
+                }
+            }
+        }
+
+        return result ?: parserError("Missing 'emailProvider' element")
+    }
+
+    private fun parseEmailProvider(): AutoconfigParserResult {
+        var domainFound = false
+        var incomingServerSettings: IncomingServerSettings? = null
+        var outgoingServerSettings: OutgoingServerSettings? = null
+
+        // The 'id' attribute is required (but not really used) by Thunderbird desktop.
+        val emailProviderId = pullParser.getAttributeValue(null, "id")
+        if (emailProviderId == null) {
+            parserError("Missing 'emailProvider.id' attribute")
+        } else if (!emailProviderId.isValidHostname()) {
+            parserError("Invalid 'emailProvider.id' attribute")
+        }
+
+        readElement { eventType ->
+            if (eventType == XmlPullParser.START_TAG) {
+                when (pullParser.name) {
+                    "domain" -> {
+                        val domain = readText()
+                        if (domain.isValidHostname()) {
+                            domainFound = true
+                        }
+                    }
+                    "incomingServer" -> {
+                        val serverSettings = parseServer("imap", ::createImapServerSettings)
+                        if (incomingServerSettings == null) {
+                            incomingServerSettings = serverSettings
+                        }
+                    }
+                    "outgoingServer" -> {
+                        val serverSettings = parseServer("smtp", ::createSmtpServerSettings)
+                        if (outgoingServerSettings == null) {
+                            outgoingServerSettings = serverSettings
+                        }
+                    }
+                    else -> {
+                        skipElement()
+                    }
+                }
+            }
+        }
+
+        // Thunderbird desktop requires at least one valid 'domain' element.
+        if (!domainFound) {
+            parserError("Valid 'domain' element required")
+        }
+
+        return AutoconfigParserResult.Settings(
+            incomingServerSettings = incomingServerSettings ?: parserError("Missing 'incomingServer' element"),
+            outgoingServerSettings = outgoingServerSettings ?: parserError("Missing 'outgoingServer' element"),
+        )
+    }
+
+    private fun <T> parseServer(
+        protocolType: String,
+        createServerSettings: ServerSettingsFactory<T>,
+    ): T? {
+        val type = pullParser.getAttributeValue(null, "type")
+        if (type != protocolType) {
+            Timber.d("Unsupported '%s[type]' value: '%s'", pullParser.name, type)
+            skipElement()
+            return null
+        }
+
+        var hostname: String? = null
+        var port: Int? = null
+        var userName: String? = null
+        val authenticationTypes = mutableListOf<AuthenticationType>()
+        var connectionSecurity: ConnectionSecurity? = null
+
+        readElement { eventType ->
+            if (eventType == XmlPullParser.START_TAG) {
+                when (pullParser.name) {
+                    "hostname" -> hostname = readHostname()
+                    "port" -> port = readPort()
+                    "username" -> userName = readUsername()
+                    "authentication" -> readAuthentication(authenticationTypes)
+                    "socketType" -> connectionSecurity = readSocketType()
+                }
+            }
+        }
+
+        val finalHostname = hostname ?: parserError("Missing 'hostname' element")
+        val finalPort = port ?: parserError("Missing 'port' element")
+        val finalUserName = userName ?: parserError("Missing 'username' element")
+        val finalAuthenticationTypes = if (authenticationTypes.isNotEmpty()) {
+            authenticationTypes.toList()
+        } else {
+            parserError("No usable 'authentication' element found")
+        }
+        val finalConnectionSecurity = connectionSecurity ?: parserError("Missing 'socketType' element")
+
+        return createServerSettings(
+            finalHostname.toHostname(),
+            finalPort.toPort(),
+            finalConnectionSecurity,
+            finalAuthenticationTypes,
+            finalUserName,
+        )
+    }
+
+    private fun readHostname(): String {
+        val hostNameText = readText()
+        val hostName = hostNameText.replaceVariables()
+        return hostName.takeIf { it.isValidHostname() }
+            ?: parserError("Invalid 'hostname' value: '$hostNameText'")
+    }
+
+    private fun readPort(): Int {
+        val portText = readText()
+        return portText.toIntOrNull()?.takeIf { it.isValidPort() }
+            ?: parserError("Invalid 'port' value: '$portText'")
+    }
+
+    private fun readUsername(): String = readText().replaceVariables()
+
+    private fun readAuthentication(authenticationTypes: MutableList<AuthenticationType>) {
+        val authenticationType = readText().toAuthenticationType() ?: return
+        authenticationTypes.add(authenticationType)
+    }
+
+    private fun readSocketType() = readText().toConnectionSecurity()
+
+    private fun String.toAuthenticationType(): AuthenticationType? {
+        return when (this) {
+            "OAuth2" -> OAuth2
+            "password-cleartext" -> PasswordCleartext
+            "password-encrypted" -> PasswordEncrypted
+            else -> {
+                Timber.d("Ignoring unknown 'authentication' value '$this'")
+                null
+            }
+        }
+    }
+
+    private fun String.toConnectionSecurity(): ConnectionSecurity {
+        return when (this) {
+            "SSL" -> TLS
+            "STARTTLS" -> StartTLS
+            else -> parserError("Unknown 'socketType' value: '$this'")
+        }
+    }
+
+    private fun readElement(block: (Int) -> Unit) {
+        require(pullParser.eventType == XmlPullParser.START_TAG)
+
+        val tagName = pullParser.name
+        val depth = pullParser.depth
+        while (true) {
+            when (val eventType = pullParser.next()) {
+                XmlPullParser.END_DOCUMENT -> {
+                    parserError("End of document reached while reading element '$tagName'")
+                }
+                XmlPullParser.END_TAG -> {
+                    if (pullParser.name == tagName && pullParser.depth == depth) return
+                }
+                else -> {
+                    block(eventType)
+                }
+            }
+        }
+    }
+
+    private fun readText(): String {
+        var text = ""
+        readElement { eventType ->
+            when (eventType) {
+                XmlPullParser.TEXT -> {
+                    text = pullParser.text
+                }
+                else -> {
+                    parserError("Expected text, but got ${XmlPullParser.TYPES[eventType]}")
+                }
+            }
+        }
+
+        return text
+    }
+
+    private fun skipElement() {
+        Timber.d("Skipping element '%s'", pullParser.name)
+        readElement { /* Do nothing */ }
+    }
+
+    private fun parserError(message: String): Nothing {
+        throw AutoconfigParserException(message)
+    }
+
+    private fun String.isValidHostname(): Boolean {
+        val cleanUpHostName = HostNameUtils.cleanUpHostName(this)
+        return HostNameUtils.isLegalHostNameOrIP(cleanUpHostName) != null
+    }
+
+    @Suppress("MagicNumber")
+    private fun Int.isValidPort() = this in 0..65535
+
+    private fun String.replaceVariables(): String {
+        return replace("%EMAILDOMAIN%", domain)
+            .replace("%EMAILLOCALPART%", localPart)
+            .replace("%EMAILADDRESS%", email.address)
+    }
+
+    private fun createImapServerSettings(
+        hostname: Hostname,
+        port: Port,
+        connectionSecurity: ConnectionSecurity,
+        authenticationTypes: List<AuthenticationType>,
+        username: String,
+    ): ImapServerSettings {
+        return ImapServerSettings(hostname, port, connectionSecurity, authenticationTypes, username)
+    }
+
+    private fun createSmtpServerSettings(
+        hostname: Hostname,
+        port: Port,
+        connectionSecurity: ConnectionSecurity,
+        authenticationTypes: List<AuthenticationType>,
+        username: String,
+    ): SmtpServerSettings {
+        return SmtpServerSettings(hostname, port, connectionSecurity, authenticationTypes, username)
+    }
+}
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/RealSubDomainExtractor.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/RealSubDomainExtractor.kt
new file mode 100644
index 0000000000000000000000000000000000000000..1ba2f4200e7f768f9baab1870e8465f1ded05d26
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/RealSubDomainExtractor.kt
@@ -0,0 +1,26 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.core.common.net.Domain
+import app.k9mail.core.common.net.toDomain
+
+internal class RealSubDomainExtractor(private val baseDomainExtractor: BaseDomainExtractor) : SubDomainExtractor {
+    @Suppress("ReturnCount")
+    override fun extractSubDomain(domain: Domain): Domain? {
+        val baseDomain = baseDomainExtractor.extractBaseDomain(domain)
+        if (baseDomain == domain) {
+            // The domain doesn't have a sub domain.
+            return null
+        }
+
+        val baseDomainString = baseDomain.value
+        val domainPrefix = domain.value.removeSuffix(".$baseDomainString")
+        val index = domainPrefix.indexOf('.')
+        if (index == -1) {
+            // The prefix is the sub domain. When we remove it only the base domain remains.
+            return baseDomain
+        }
+
+        val prefixWithoutFirstLabel = domainPrefix.substring(index + 1)
+        return "$prefixWithoutFirstLabel.$baseDomainString".toDomain()
+    }
+}
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/SubDomainExtractor.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/SubDomainExtractor.kt
new file mode 100644
index 0000000000000000000000000000000000000000..0935b772413449df5d668994403e5fb0ce615af5
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/SubDomainExtractor.kt
@@ -0,0 +1,12 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.core.common.net.Domain
+
+/**
+ * Extract the sub domain from a host name.
+ *
+ * An implementation needs to respect the [Public Suffix List](https://publicsuffix.org/).
+ */
+internal interface SubDomainExtractor {
+    fun extractSubDomain(domain: Domain): Domain?
+}
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/SuspendableAutoconfigParser.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/SuspendableAutoconfigParser.kt
new file mode 100644
index 0000000000000000000000000000000000000000..bd523482dc8a94c04f71653dcbbd41284857fe25
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/SuspendableAutoconfigParser.kt
@@ -0,0 +1,14 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.core.common.mail.EmailAddress
+import java.io.InputStream
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runInterruptible
+
+internal class SuspendableAutoconfigParser(private val autoconfigParser: AutoconfigParser) {
+    suspend fun parseSettings(inputStream: InputStream, email: EmailAddress): AutoconfigParserResult {
+        return runInterruptible(Dispatchers.IO) {
+            autoconfigParser.parseSettings(inputStream, email)
+        }
+    }
+}
diff --git a/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/SuspendableMxResolver.kt b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/SuspendableMxResolver.kt
new file mode 100644
index 0000000000000000000000000000000000000000..a620deea899f7ed1bb9c514b0afdf8a6f7034670
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/main/kotlin/app/k9mail/autodiscovery/autoconfig/SuspendableMxResolver.kt
@@ -0,0 +1,13 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.core.common.net.Domain
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runInterruptible
+
+internal class SuspendableMxResolver(private val mxResolver: MxResolver) {
+    suspend fun lookup(domain: Domain): MxLookupResult {
+        return runInterruptible(Dispatchers.IO) {
+            mxResolver.lookup(domain)
+        }
+    }
+}
diff --git a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigDiscoveryTest.kt b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigDiscoveryTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d077ce2e3bb250a66dc1e0b14383c32cf3f1037b
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigDiscoveryTest.kt
@@ -0,0 +1,69 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.autodiscovery.autoconfig.MockAutoconfigFetcher.Companion.RESULT_ONE
+import app.k9mail.autodiscovery.autoconfig.MockAutoconfigFetcher.Companion.RESULT_TWO
+import app.k9mail.core.common.mail.toUserEmailAddress
+import app.k9mail.core.common.net.toDomain
+import assertk.assertThat
+import assertk.assertions.containsExactly
+import assertk.assertions.extracting
+import assertk.assertions.hasSize
+import assertk.assertions.isEqualTo
+import kotlin.test.Test
+import kotlinx.coroutines.test.runTest
+import okhttp3.HttpUrl.Companion.toHttpUrl
+
+private val IRRELEVANT_EMAIL_ADDRESS = "irrelevant@domain.example".toUserEmailAddress()
+
+class AutoconfigDiscoveryTest {
+    private val urlProvider = MockAutoconfigUrlProvider()
+    private val autoconfigFetcher = MockAutoconfigFetcher()
+    private val discovery = AutoconfigDiscovery(urlProvider, autoconfigFetcher)
+
+    @Test
+    fun `AutoconfigFetcher and AutoconfigParser should only be called when AutoDiscoveryRunnable is run`() = runTest {
+        val emailAddress = "user@domain.example".toUserEmailAddress()
+        val autoconfigUrl = "https://autoconfig.domain.invalid/mail/config-v1.1.xml".toHttpUrl()
+        urlProvider.addResult(listOf(autoconfigUrl))
+        autoconfigFetcher.addResult(RESULT_ONE)
+
+        val autoDiscoveryRunnables = discovery.initDiscovery(emailAddress)
+
+        assertThat(autoDiscoveryRunnables).hasSize(1)
+        assertThat(urlProvider.callArguments).containsExactly("domain.example".toDomain() to emailAddress)
+        assertThat(autoconfigFetcher.callCount).isEqualTo(0)
+
+        val discoveryResult = autoDiscoveryRunnables.first().run()
+
+        assertThat(autoconfigFetcher.callArguments).containsExactly(autoconfigUrl to emailAddress)
+        assertThat(discoveryResult).isEqualTo(RESULT_ONE)
+    }
+
+    @Test
+    fun `Two Autoconfig URLs should return two AutoDiscoveryRunnables`() = runTest {
+        val urlOne = "https://autoconfig.domain1.invalid/mail/config-v1.1.xml".toHttpUrl()
+        val urlTwo = "https://autoconfig.domain2.invalid/mail/config-v1.1.xml".toHttpUrl()
+
+        urlProvider.addResult(listOf(urlOne, urlTwo))
+        autoconfigFetcher.apply {
+            addResult(RESULT_ONE)
+            addResult(RESULT_TWO)
+        }
+
+        val autoDiscoveryRunnables = discovery.initDiscovery(IRRELEVANT_EMAIL_ADDRESS)
+
+        assertThat(autoDiscoveryRunnables).hasSize(2)
+
+        val discoveryResultOne = autoDiscoveryRunnables[0].run()
+
+        assertThat(autoconfigFetcher.callArguments).extracting { it.first }.containsExactly(urlOne)
+        assertThat(discoveryResultOne).isEqualTo(RESULT_ONE)
+
+        autoconfigFetcher.callArguments.clear()
+
+        val discoveryResultTwo = autoDiscoveryRunnables[1].run()
+
+        assertThat(autoconfigFetcher.callArguments).extracting { it.first }.containsExactly(urlTwo)
+        assertThat(discoveryResultTwo).isEqualTo(RESULT_TWO)
+    }
+}
diff --git a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/IspDbAutoconfigUrlProviderTest.kt b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/IspDbAutoconfigUrlProviderTest.kt
index 2bbb3f3899c80caee1f62eece4163509e187b2aa..2b6613ffcd58c6902540c0ee233ba4d7449ecfed 100644
--- a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/IspDbAutoconfigUrlProviderTest.kt
+++ b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/IspDbAutoconfigUrlProviderTest.kt
@@ -1,7 +1,9 @@
 package app.k9mail.autodiscovery.autoconfig
 
+import app.k9mail.core.common.net.toDomain
 import assertk.assertThat
 import assertk.assertions.containsExactly
+import assertk.assertions.extracting
 import org.junit.Test
 
 class IspDbAutoconfigUrlProviderTest {
@@ -9,9 +11,11 @@ class IspDbAutoconfigUrlProviderTest {
 
     @Test
     fun `getAutoconfigUrls with ASCII email address`() {
-        val autoconfigUrls = urlProvider.getAutoconfigUrls("test@domain.example")
+        val domain = "domain.example".toDomain()
 
-        assertThat(autoconfigUrls.map { it.toString() }).containsExactly(
+        val autoconfigUrls = urlProvider.getAutoconfigUrls(domain)
+
+        assertThat(autoconfigUrls).extracting { it.toString() }.containsExactly(
             "https://autoconfig.thunderbird.net/v1.1/domain.example",
         )
     }
diff --git a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/MiniDnsMxResolverTest.kt b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/MiniDnsMxResolverTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d4bf7e8d87682686ed27a672c70257d934424428
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/MiniDnsMxResolverTest.kt
@@ -0,0 +1,47 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.core.common.net.toDomain
+import assertk.all
+import assertk.assertThat
+import assertk.assertions.containsExactlyInAnyOrder
+import assertk.assertions.extracting
+import assertk.assertions.index
+import assertk.assertions.isEmpty
+import assertk.assertions.isEqualTo
+import assertk.assertions.isFalse
+import kotlin.test.Ignore
+import kotlin.test.Test
+
+class MiniDnsMxResolverTest {
+    private val resolver = MiniDnsMxResolver()
+
+    @Test
+    @Ignore("Requires internet")
+    fun `MX lookup for known domain`() {
+        val domain = "thunderbird.net".toDomain()
+
+        val result = resolver.lookup(domain)
+
+        assertThat(result.mxNames).extracting { it.value }.all {
+            index(0).isEqualTo("aspmx.l.google.com")
+            containsExactlyInAnyOrder(
+                "aspmx.l.google.com",
+                "alt1.aspmx.l.google.com",
+                "alt2.aspmx.l.google.com",
+                "alt4.aspmx.l.google.com",
+                "alt3.aspmx.l.google.com",
+            )
+        }
+    }
+
+    @Test
+    @Ignore("Requires internet")
+    fun `MX lookup for non-existent domain`() {
+        val domain = "test.invalid".toDomain()
+
+        val result = resolver.lookup(domain)
+
+        assertThat(result.mxNames).isEmpty()
+        assertThat(result.isTrusted).isFalse()
+    }
+}
diff --git a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/MockAutoconfigFetcher.kt b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/MockAutoconfigFetcher.kt
new file mode 100644
index 0000000000000000000000000000000000000000..ebdcfefd3cb555fcf7bfed88e70b7d465869ef0c
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/MockAutoconfigFetcher.kt
@@ -0,0 +1,74 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.autodiscovery.api.AuthenticationType.PasswordCleartext
+import app.k9mail.autodiscovery.api.AuthenticationType.PasswordEncrypted
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.autodiscovery.api.ConnectionSecurity.StartTLS
+import app.k9mail.autodiscovery.api.ConnectionSecurity.TLS
+import app.k9mail.autodiscovery.api.ImapServerSettings
+import app.k9mail.autodiscovery.api.SmtpServerSettings
+import app.k9mail.core.common.mail.EmailAddress
+import app.k9mail.core.common.net.toHostname
+import app.k9mail.core.common.net.toPort
+import okhttp3.HttpUrl
+
+internal class MockAutoconfigFetcher : AutoconfigFetcher {
+    val callArguments = mutableListOf<Pair<HttpUrl, EmailAddress>>()
+
+    val callCount: Int
+        get() = callArguments.size
+
+    private val results = mutableListOf<AutoDiscoveryResult>()
+
+    fun addResult(discoveryResult: AutoDiscoveryResult) {
+        results.add(discoveryResult)
+    }
+
+    override suspend fun fetchAutoconfig(autoconfigUrl: HttpUrl, email: EmailAddress): AutoDiscoveryResult {
+        callArguments.add(autoconfigUrl to email)
+
+        check(results.isNotEmpty()) {
+            "MockAutoconfigFetcher.fetchAutoconfig($autoconfigUrl) called but no result provided"
+        }
+        return results.removeAt(0)
+    }
+
+    companion object {
+        val RESULT_ONE = AutoDiscoveryResult.Settings(
+            incomingServerSettings = ImapServerSettings(
+                hostname = "imap.domain.example".toHostname(),
+                port = 993.toPort(),
+                connectionSecurity = TLS,
+                authenticationTypes = listOf(PasswordCleartext),
+                username = "irrelevant@domain.example",
+            ),
+            outgoingServerSettings = SmtpServerSettings(
+                hostname = "smtp.domain.example".toHostname(),
+                port = 465.toPort(),
+                connectionSecurity = TLS,
+                authenticationTypes = listOf(PasswordCleartext),
+                username = "irrelevant@domain.example",
+            ),
+            isTrusted = true,
+            source = "result 1",
+        )
+        val RESULT_TWO = AutoDiscoveryResult.Settings(
+            incomingServerSettings = ImapServerSettings(
+                hostname = "imap.company.example".toHostname(),
+                port = 143.toPort(),
+                connectionSecurity = StartTLS,
+                authenticationTypes = listOf(PasswordEncrypted),
+                username = "irrelevant@company.example",
+            ),
+            outgoingServerSettings = SmtpServerSettings(
+                hostname = "smtp.company.example".toHostname(),
+                port = 587.toPort(),
+                connectionSecurity = StartTLS,
+                authenticationTypes = listOf(PasswordEncrypted),
+                username = "irrelevant@company.example",
+            ),
+            isTrusted = true,
+            source = "result 2",
+        )
+    }
+}
diff --git a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/MockAutoconfigUrlProvider.kt b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/MockAutoconfigUrlProvider.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d3a4d1c279ae516de9468730c42673b59c75062a
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/MockAutoconfigUrlProvider.kt
@@ -0,0 +1,25 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.core.common.mail.EmailAddress
+import app.k9mail.core.common.net.Domain
+import okhttp3.HttpUrl
+
+internal class MockAutoconfigUrlProvider : AutoconfigUrlProvider {
+    val callArguments = mutableListOf<Pair<Domain, EmailAddress?>>()
+
+    val callCount: Int
+        get() = callArguments.size
+
+    private val results = mutableListOf<List<HttpUrl>>()
+
+    fun addResult(urls: List<HttpUrl>) {
+        results.add(urls)
+    }
+
+    override fun getAutoconfigUrls(domain: Domain, email: EmailAddress?): List<HttpUrl> {
+        callArguments.add(domain to email)
+
+        check(results.isNotEmpty()) { "getAutoconfigUrls($domain, $email) called but no result provided" }
+        return results.removeAt(0)
+    }
+}
diff --git a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/MockMxResolver.kt b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/MockMxResolver.kt
new file mode 100644
index 0000000000000000000000000000000000000000..60285566260185c6a9bbbd0ee03bc8ff66401b44
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/MockMxResolver.kt
@@ -0,0 +1,27 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.core.common.net.Domain
+
+class MockMxResolver : MxResolver {
+    val callArguments = mutableListOf<Domain>()
+
+    val callCount: Int
+        get() = callArguments.size
+
+    private val results = mutableListOf<MxLookupResult>()
+
+    fun addResult(domain: Domain, isTrusted: Boolean = true) {
+        results.add(MxLookupResult(mxNames = listOf(domain), isTrusted = isTrusted))
+    }
+
+    fun addResult(domains: List<Domain>) {
+        results.add(MxLookupResult(mxNames = domains, isTrusted = true))
+    }
+
+    override fun lookup(domain: Domain): MxLookupResult {
+        callArguments.add(domain)
+
+        check(results.isNotEmpty()) { "lookup($domain) called but no result provided" }
+        return results.removeAt(0)
+    }
+}
diff --git a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/MxLookupAutoconfigDiscoveryTest.kt b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/MxLookupAutoconfigDiscoveryTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..0e12e3c0824a73a4b7c0efb37988639517d2b3ac
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/MxLookupAutoconfigDiscoveryTest.kt
@@ -0,0 +1,128 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult.NoUsableSettingsFound
+import app.k9mail.autodiscovery.autoconfig.MockAutoconfigFetcher.Companion.RESULT_ONE
+import app.k9mail.core.common.mail.toUserEmailAddress
+import app.k9mail.core.common.net.toDomain
+import assertk.assertThat
+import assertk.assertions.containsExactly
+import assertk.assertions.extracting
+import assertk.assertions.hasSize
+import assertk.assertions.isEqualTo
+import kotlin.test.Test
+import kotlinx.coroutines.test.runTest
+import okhttp3.HttpUrl.Companion.toHttpUrl
+
+class MxLookupAutoconfigDiscoveryTest {
+    private val mxResolver = MockMxResolver()
+    private val baseDomainExtractor = OkHttpBaseDomainExtractor()
+    private val urlProvider = MockAutoconfigUrlProvider()
+    private val autoconfigFetcher = MockAutoconfigFetcher()
+    private val discovery = MxLookupAutoconfigDiscovery(
+        mxResolver = SuspendableMxResolver(mxResolver),
+        baseDomainExtractor = baseDomainExtractor,
+        subDomainExtractor = RealSubDomainExtractor(baseDomainExtractor),
+        urlProvider = urlProvider,
+        autoconfigFetcher = autoconfigFetcher,
+    )
+
+    @Test
+    fun `AutoconfigUrlProvider should be called with MX base domain`() = runTest {
+        val emailAddress = "user@company.example".toUserEmailAddress()
+        mxResolver.addResult("mx.emailprovider.example".toDomain())
+        urlProvider.addResult(listOf("https://ispdb.invalid/emailprovider.example".toHttpUrl()))
+        autoconfigFetcher.addResult(RESULT_ONE)
+
+        val autoDiscoveryRunnables = discovery.initDiscovery(emailAddress)
+
+        assertThat(autoDiscoveryRunnables).hasSize(1)
+        assertThat(mxResolver.callCount).isEqualTo(0)
+        assertThat(autoconfigFetcher.callCount).isEqualTo(0)
+
+        val discoveryResult = autoDiscoveryRunnables.first().run()
+
+        assertThat(mxResolver.callArguments).containsExactly("company.example".toDomain())
+        assertThat(urlProvider.callArguments).extracting { it.first }
+            .containsExactly("emailprovider.example".toDomain())
+        assertThat(autoconfigFetcher.callCount).isEqualTo(1)
+        assertThat(discoveryResult).isEqualTo(RESULT_ONE)
+    }
+
+    @Test
+    fun `AutoconfigUrlProvider should be called with MX base domain and subdomain`() = runTest {
+        val emailAddress = "user@company.example".toUserEmailAddress()
+        mxResolver.addResult("mx.something.emailprovider.example".toDomain())
+        urlProvider.apply {
+            addResult(listOf("https://ispdb.invalid/something.emailprovider.example".toHttpUrl()))
+            addResult(listOf("https://ispdb.invalid/emailprovider.example".toHttpUrl()))
+        }
+        autoconfigFetcher.apply {
+            addResult(NoUsableSettingsFound)
+            addResult(NoUsableSettingsFound)
+        }
+
+        val autoDiscoveryRunnables = discovery.initDiscovery(emailAddress)
+        val discoveryResult = autoDiscoveryRunnables.first().run()
+
+        assertThat(urlProvider.callArguments).extracting { it.first }.containsExactly(
+            "something.emailprovider.example".toDomain(),
+            "emailprovider.example".toDomain(),
+        )
+        assertThat(autoconfigFetcher.callCount).isEqualTo(2)
+        assertThat(discoveryResult).isEqualTo(NoUsableSettingsFound)
+    }
+
+    @Test
+    fun `skip Autoconfig lookup when MX lookup does not return a result`() = runTest {
+        val emailAddress = "user@company.example".toUserEmailAddress()
+        mxResolver.addResult(emptyList())
+
+        val autoDiscoveryRunnables = discovery.initDiscovery(emailAddress)
+        val discoveryResult = autoDiscoveryRunnables.first().run()
+
+        assertThat(mxResolver.callCount).isEqualTo(1)
+        assertThat(urlProvider.callCount).isEqualTo(0)
+        assertThat(autoconfigFetcher.callCount).isEqualTo(0)
+        assertThat(discoveryResult).isEqualTo(NoUsableSettingsFound)
+    }
+
+    @Test
+    fun `skip Autoconfig lookup when base domain of MX record is email domain`() = runTest {
+        val emailAddress = "user@company.example".toUserEmailAddress()
+        mxResolver.addResult("mx.company.example".toDomain())
+
+        val autoDiscoveryRunnables = discovery.initDiscovery(emailAddress)
+        val discoveryResult = autoDiscoveryRunnables.first().run()
+
+        assertThat(mxResolver.callCount).isEqualTo(1)
+        assertThat(urlProvider.callCount).isEqualTo(0)
+        assertThat(autoconfigFetcher.callCount).isEqualTo(0)
+        assertThat(discoveryResult).isEqualTo(NoUsableSettingsFound)
+    }
+
+    @Test
+    fun `isTrusted should be false when MxLookupResult_isTrusted is false`() = runTest {
+        val emailAddress = "user@company.example".toUserEmailAddress()
+        mxResolver.addResult("mx.emailprovider.example".toDomain(), isTrusted = false)
+        urlProvider.addResult(listOf("https://ispdb.invalid/emailprovider.example".toHttpUrl()))
+        autoconfigFetcher.addResult(RESULT_ONE.copy(isTrusted = true))
+
+        val autoDiscoveryRunnables = discovery.initDiscovery(emailAddress)
+        val discoveryResult = autoDiscoveryRunnables.first().run()
+
+        assertThat(discoveryResult).isEqualTo(RESULT_ONE.copy(isTrusted = false))
+    }
+
+    @Test
+    fun `isTrusted should be false when AutoDiscoveryResult_isTrusted from AutoconfigFetcher is false`() = runTest {
+        val emailAddress = "user@company.example".toUserEmailAddress()
+        mxResolver.addResult("mx.emailprovider.example".toDomain(), isTrusted = true)
+        urlProvider.addResult(listOf("https://ispdb.invalid/emailprovider.example".toHttpUrl()))
+        autoconfigFetcher.addResult(RESULT_ONE.copy(isTrusted = false))
+
+        val autoDiscoveryRunnables = discovery.initDiscovery(emailAddress)
+        val discoveryResult = autoDiscoveryRunnables.first().run()
+
+        assertThat(discoveryResult).isEqualTo(RESULT_ONE.copy(isTrusted = false))
+    }
+}
diff --git a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/OkHttpBaseDomainExtractorTest.kt b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/OkHttpBaseDomainExtractorTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..1b75bb2d6f36f6c71925c11267ddba78c2552f58
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/OkHttpBaseDomainExtractorTest.kt
@@ -0,0 +1,46 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.core.common.net.toDomain
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import org.junit.Test
+
+class OkHttpBaseDomainExtractorTest {
+    private val baseDomainExtractor = OkHttpBaseDomainExtractor()
+
+    @Test
+    fun `basic domain`() {
+        val domain = "domain.example".toDomain()
+
+        val result = baseDomainExtractor.extractBaseDomain(domain)
+
+        assertThat(result).isEqualTo(domain)
+    }
+
+    @Test
+    fun `basic subdomain`() {
+        val domain = "subdomain.domain.example".toDomain()
+
+        val result = baseDomainExtractor.extractBaseDomain(domain)
+
+        assertThat(result).isEqualTo("domain.example".toDomain())
+    }
+
+    @Test
+    fun `domain with public suffix`() {
+        val domain = "example.co.uk".toDomain()
+
+        val result = baseDomainExtractor.extractBaseDomain(domain)
+
+        assertThat(result).isEqualTo(domain)
+    }
+
+    @Test
+    fun `subdomain with public suffix`() {
+        val domain = "subdomain.example.co.uk".toDomain()
+
+        val result = baseDomainExtractor.extractBaseDomain(domain)
+
+        assertThat(result).isEqualTo("example.co.uk".toDomain())
+    }
+}
diff --git a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigFetcherTest.kt b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/OkHttpFetcherTest.kt
similarity index 50%
rename from feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigFetcherTest.kt
rename to feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/OkHttpFetcherTest.kt
index 9e713f4f305cce97a157ebbe059a5d3b7a18f174..a5a20fe8ec61881ec63b30a4949c43a6e67a9fdd 100644
--- a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/AutoconfigFetcherTest.kt
+++ b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/OkHttpFetcherTest.kt
@@ -1,30 +1,34 @@
 package app.k9mail.autodiscovery.autoconfig
 
+import assertk.all
+import assertk.assertFailure
 import assertk.assertThat
 import assertk.assertions.isEqualTo
-import assertk.assertions.isNull
-import kotlin.test.assertNotNull
+import assertk.assertions.isInstanceOf
+import assertk.assertions.prop
+import java.net.UnknownHostException
+import kotlinx.coroutines.test.runTest
 import okhttp3.HttpUrl.Companion.toHttpUrl
 import okhttp3.OkHttpClient
 import okhttp3.mockwebserver.MockResponse
 import okhttp3.mockwebserver.MockWebServer
 import org.junit.Test
 
-class AutoconfigFetcherTest {
-    private val fetcher = AutoconfigFetcher(OkHttpClient.Builder().build())
+class OkHttpFetcherTest {
+    private val fetcher = OkHttpFetcher(OkHttpClient.Builder().build())
 
     @Test
-    fun shouldHandleNonexistentUrl() {
+    fun shouldHandleNonexistentUrl() = runTest {
         val nonExistentUrl =
             "https://autoconfig.domain.invalid/mail/config-v1.1.xml?emailaddress=test%40domain.example".toHttpUrl()
 
-        val inputStream = fetcher.fetchAutoconfigFile(nonExistentUrl)
-
-        assertThat(inputStream).isNull()
+        assertFailure {
+            fetcher.fetch(nonExistentUrl)
+        }.isInstanceOf<UnknownHostException>()
     }
 
     @Test
-    fun shouldHandleEmptyResponse() {
+    fun shouldHandleEmptyResponse() = runTest {
         val server = MockWebServer().apply {
             this.enqueue(
                 MockResponse()
@@ -35,10 +39,10 @@ class AutoconfigFetcherTest {
         }
         val url = server.url("/empty/")
 
-        val inputStream = fetcher.fetchAutoconfigFile(url)
+        val result = fetcher.fetch(url)
 
-        assertNotNull(inputStream) { inputStream ->
-            assertThat(inputStream.available()).isEqualTo(0)
+        assertThat(result).isInstanceOf<HttpFetchResult.SuccessResponse>().all {
+            prop(HttpFetchResult.SuccessResponse::inputStream).transform { it.available() }.isEqualTo(0)
         }
     }
 }
diff --git a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/ProviderAutoconfigUrlProviderTest.kt b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/ProviderAutoconfigUrlProviderTest.kt
index 18607eca9c5f4c46b3522afd31a5cd417e806f3d..2a2250dfd1f0c82ecbfa52332e1928469393b175 100644
--- a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/ProviderAutoconfigUrlProviderTest.kt
+++ b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/ProviderAutoconfigUrlProviderTest.kt
@@ -1,16 +1,22 @@
 package app.k9mail.autodiscovery.autoconfig
 
+import app.k9mail.core.common.mail.toUserEmailAddress
+import app.k9mail.core.common.net.toDomain
 import assertk.assertThat
 import assertk.assertions.containsExactly
 import org.junit.Test
 
 class ProviderAutoconfigUrlProviderTest {
+    private val domain = "domain.example".toDomain()
+    private val email = "test@domain.example".toUserEmailAddress()
+
     @Test
     fun `getAutoconfigUrls with http allowed and email address included`() {
         val urlProvider = ProviderAutoconfigUrlProvider(
             AutoconfigUrlConfig(httpsOnly = false, includeEmailAddress = true),
         )
-        val autoconfigUrls = urlProvider.getAutoconfigUrls("test@domain.example")
+
+        val autoconfigUrls = urlProvider.getAutoconfigUrls(domain, email)
 
         assertThat(autoconfigUrls.map { it.toString() }).containsExactly(
             "https://autoconfig.domain.example/mail/config-v1.1.xml?emailaddress=test%40domain.example",
@@ -25,7 +31,8 @@ class ProviderAutoconfigUrlProviderTest {
         val urlProvider = ProviderAutoconfigUrlProvider(
             AutoconfigUrlConfig(httpsOnly = true, includeEmailAddress = true),
         )
-        val autoconfigUrls = urlProvider.getAutoconfigUrls("test@domain.example")
+
+        val autoconfigUrls = urlProvider.getAutoconfigUrls(domain, email)
 
         assertThat(autoconfigUrls.map { it.toString() }).containsExactly(
             "https://autoconfig.domain.example/mail/config-v1.1.xml?emailaddress=test%40domain.example",
@@ -38,7 +45,8 @@ class ProviderAutoconfigUrlProviderTest {
         val urlProvider = ProviderAutoconfigUrlProvider(
             AutoconfigUrlConfig(httpsOnly = true, includeEmailAddress = false),
         )
-        val autoconfigUrls = urlProvider.getAutoconfigUrls("test@domain.example")
+
+        val autoconfigUrls = urlProvider.getAutoconfigUrls(domain, email)
 
         assertThat(autoconfigUrls.map { it.toString() }).containsExactly(
             "https://autoconfig.domain.example/mail/config-v1.1.xml",
@@ -51,7 +59,24 @@ class ProviderAutoconfigUrlProviderTest {
         val urlProvider = ProviderAutoconfigUrlProvider(
             AutoconfigUrlConfig(httpsOnly = false, includeEmailAddress = false),
         )
-        val autoconfigUrls = urlProvider.getAutoconfigUrls("test@domain.example")
+
+        val autoconfigUrls = urlProvider.getAutoconfigUrls(domain, email)
+
+        assertThat(autoconfigUrls.map { it.toString() }).containsExactly(
+            "https://autoconfig.domain.example/mail/config-v1.1.xml",
+            "https://domain.example/.well-known/autoconfig/mail/config-v1.1.xml",
+            "http://autoconfig.domain.example/mail/config-v1.1.xml",
+            "http://domain.example/.well-known/autoconfig/mail/config-v1.1.xml",
+        )
+    }
+
+    @Test
+    fun `getAutoconfigUrls with http allowed and email address included, but none provided`() {
+        val urlProvider = ProviderAutoconfigUrlProvider(
+            AutoconfigUrlConfig(httpsOnly = false, includeEmailAddress = true),
+        )
+
+        val autoconfigUrls = urlProvider.getAutoconfigUrls(domain)
 
         assertThat(autoconfigUrls.map { it.toString() }).containsExactly(
             "https://autoconfig.domain.example/mail/config-v1.1.xml",
diff --git a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/RealAutoconfigParserTest.kt b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/RealAutoconfigParserTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..3c4c9896a000fd0ea3bc7ec2769066eaa92d503b
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/RealAutoconfigParserTest.kt
@@ -0,0 +1,558 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.autodiscovery.api.AuthenticationType.OAuth2
+import app.k9mail.autodiscovery.api.AuthenticationType.PasswordCleartext
+import app.k9mail.autodiscovery.api.ConnectionSecurity.StartTLS
+import app.k9mail.autodiscovery.api.ConnectionSecurity.TLS
+import app.k9mail.autodiscovery.api.ImapServerSettings
+import app.k9mail.autodiscovery.api.SmtpServerSettings
+import app.k9mail.autodiscovery.autoconfig.AutoconfigParserResult.ParserError
+import app.k9mail.autodiscovery.autoconfig.AutoconfigParserResult.Settings
+import app.k9mail.core.common.mail.toUserEmailAddress
+import app.k9mail.core.common.net.toHostname
+import app.k9mail.core.common.net.toPort
+import assertk.assertThat
+import assertk.assertions.hasMessage
+import assertk.assertions.isEqualTo
+import assertk.assertions.isInstanceOf
+import assertk.assertions.isNotNull
+import assertk.assertions.prop
+import java.io.InputStream
+import org.intellij.lang.annotations.Language
+import org.jsoup.Jsoup
+import org.jsoup.nodes.Document
+import org.jsoup.nodes.Element
+import org.jsoup.parser.Parser
+import org.junit.Test
+
+private const val PRINT_MODIFIED_XML = false
+
+class RealAutoconfigParserTest {
+    private val parser = RealAutoconfigParser()
+
+    @Language("XML")
+    private val minimalConfig =
+        """
+        <?xml version="1.0" encoding="UTF-8"?>
+        <clientConfig version="1.1">
+          <emailProvider id="domain.example">
+            <domain>domain.example</domain>
+            <incomingServer type="imap">
+              <hostname>imap.domain.example</hostname>
+              <port>993</port>
+              <socketType>SSL</socketType>
+              <authentication>password-cleartext</authentication>
+              <username>%EMAILADDRESS%</username>
+            </incomingServer>
+            <outgoingServer type="smtp">
+              <hostname>smtp.domain.example</hostname>
+              <port>587</port>
+              <socketType>STARTTLS</socketType>
+              <authentication>password-cleartext</authentication>
+              <username>%EMAILADDRESS%</username>
+            </outgoingServer>
+          </emailProvider>
+        </clientConfig>
+        """.trimIndent()
+
+    private val irrelevantEmailAddress = "irrelevant@domain.example".toUserEmailAddress()
+
+    @Test
+    fun `minimal data`() {
+        val inputStream = minimalConfig.byteInputStream()
+
+        val result = parser.parseSettings(inputStream, email = "user@domain.example".toUserEmailAddress())
+
+        assertThat(result).isNotNull().isEqualTo(
+            Settings(
+                ImapServerSettings(
+                    hostname = "imap.domain.example".toHostname(),
+                    port = 993.toPort(),
+                    connectionSecurity = TLS,
+                    authenticationTypes = listOf(PasswordCleartext),
+                    username = "user@domain.example",
+                ),
+                SmtpServerSettings(
+                    hostname = "smtp.domain.example".toHostname(),
+                    port = 587.toPort(),
+                    connectionSecurity = StartTLS,
+                    authenticationTypes = listOf(PasswordCleartext),
+                    username = "user@domain.example",
+                ),
+            ),
+        )
+    }
+
+    @Test
+    fun `real-world data`() {
+        val inputStream = javaClass.getResourceAsStream("/2022-11-19-googlemail.com.xml")!!
+
+        val result = parser.parseSettings(inputStream, email = "test@gmail.com".toUserEmailAddress())
+
+        assertThat(result).isNotNull().isEqualTo(
+            Settings(
+                ImapServerSettings(
+                    hostname = "imap.gmail.com".toHostname(),
+                    port = 993.toPort(),
+                    connectionSecurity = TLS,
+                    authenticationTypes = listOf(OAuth2, PasswordCleartext),
+                    username = "test@gmail.com",
+                ),
+                SmtpServerSettings(
+                    hostname = "smtp.gmail.com".toHostname(),
+                    port = 465.toPort(),
+                    connectionSecurity = TLS,
+                    authenticationTypes = listOf(OAuth2, PasswordCleartext),
+                    username = "test@gmail.com",
+                ),
+            ),
+        )
+    }
+
+    @Test
+    fun `replace variables`() {
+        val inputStream = minimalConfig.withModifications {
+            element("incomingServer > hostname").text("%EMAILLOCALPART%.domain.example")
+            element("outgoingServer > hostname").text("%EMAILLOCALPART%.outgoing.domain.example")
+            element("outgoingServer > username").text("%EMAILDOMAIN%")
+        }
+
+        val result = parser.parseSettings(inputStream, email = "user@domain.example".toUserEmailAddress())
+
+        assertThat(result).isNotNull().isEqualTo(
+            Settings(
+                ImapServerSettings(
+                    hostname = "user.domain.example".toHostname(),
+                    port = 993.toPort(),
+                    connectionSecurity = TLS,
+                    authenticationTypes = listOf(PasswordCleartext),
+                    username = "user@domain.example",
+                ),
+                SmtpServerSettings(
+                    hostname = "user.outgoing.domain.example".toHostname(),
+                    port = 587.toPort(),
+                    connectionSecurity = StartTLS,
+                    authenticationTypes = listOf(PasswordCleartext),
+                    username = "domain.example",
+                ),
+            ),
+        )
+    }
+
+    @Test
+    fun `data with comments`() {
+        val inputStream = minimalConfig.withModifications {
+            element("incomingServer > hostname").prepend("<!-- comment -->")
+            element("incomingServer > port").prepend("<!-- comment -->")
+            element("incomingServer > socketType").prepend("<!-- comment -->")
+            element("incomingServer > authentication").prepend("<!-- comment -->")
+            element("incomingServer > username").prepend("<!-- comment -->")
+        }
+
+        val result = parser.parseSettings(inputStream, email = "user@domain.example".toUserEmailAddress())
+
+        assertThat(result).isInstanceOf<Settings>()
+            .prop(Settings::incomingServerSettings).isEqualTo(
+                ImapServerSettings(
+                    hostname = "imap.domain.example".toHostname(),
+                    port = 993.toPort(),
+                    connectionSecurity = TLS,
+                    authenticationTypes = listOf(PasswordCleartext),
+                    username = "user@domain.example",
+                ),
+            )
+    }
+
+    @Test
+    fun `ignore unsupported 'incomingServer' type`() {
+        val inputStream = minimalConfig.withModifications {
+            element("incomingServer").insertBefore("""<incomingServer type="smtp"/>""")
+        }
+
+        val result = parser.parseSettings(inputStream, email = "user@domain.example".toUserEmailAddress())
+
+        assertThat(result).isInstanceOf<Settings>()
+            .prop(Settings::incomingServerSettings).isEqualTo(
+                ImapServerSettings(
+                    hostname = "imap.domain.example".toHostname(),
+                    port = 993.toPort(),
+                    connectionSecurity = TLS,
+                    authenticationTypes = listOf(PasswordCleartext),
+                    username = "user@domain.example",
+                ),
+            )
+    }
+
+    @Test
+    fun `ignore unsupported 'outgoingServer' type`() {
+        val inputStream = minimalConfig.withModifications {
+            element("outgoingServer").insertBefore("""<outgoingServer type="imap"/>""")
+        }
+
+        val result = parser.parseSettings(inputStream, email = "user@domain.example".toUserEmailAddress())
+
+        assertThat(result).isInstanceOf<Settings>()
+            .prop(Settings::outgoingServerSettings).isEqualTo(
+                SmtpServerSettings(
+                    hostname = "smtp.domain.example".toHostname(),
+                    port = 587.toPort(),
+                    connectionSecurity = StartTLS,
+                    authenticationTypes = listOf(PasswordCleartext),
+                    username = "user@domain.example",
+                ),
+            )
+    }
+
+    @Test
+    fun `empty authentication element should be ignored`() {
+        val inputStream = minimalConfig.withModifications {
+            element("incomingServer > authentication").insertBefore("<authentication></authentication>")
+        }
+
+        val result = parser.parseSettings(inputStream, email = "user@domain.example".toUserEmailAddress())
+
+        assertThat(result).isInstanceOf<Settings>()
+            .prop(Settings::incomingServerSettings).isEqualTo(
+                ImapServerSettings(
+                    hostname = "imap.domain.example".toHostname(),
+                    port = 993.toPort(),
+                    connectionSecurity = TLS,
+                    authenticationTypes = listOf(PasswordCleartext),
+                    username = "user@domain.example",
+                ),
+            )
+    }
+
+    @Test
+    fun `config with missing 'emailProvider id' attribute should throw`() {
+        val inputStream = minimalConfig.withModifications {
+            element("emailProvider").removeAttr("id")
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Missing 'emailProvider.id' attribute")
+    }
+
+    @Test
+    fun `config with invalid 'emailProvider id' attribute should throw`() {
+        val inputStream = minimalConfig.withModifications {
+            element("emailProvider").attr("id", "-23")
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Invalid 'emailProvider.id' attribute")
+    }
+
+    @Test
+    fun `config with missing domain element should throw`() {
+        val inputStream = minimalConfig.withModifications {
+            element("emailProvider > domain").remove()
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Valid 'domain' element required")
+    }
+
+    @Test
+    fun `config with only invalid domain elements should throw`() {
+        val inputStream = minimalConfig.withModifications {
+            element("emailProvider > domain").text("-invalid")
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Valid 'domain' element required")
+    }
+
+    @Test
+    fun `config with missing 'incomingServer' element should throw`() {
+        val inputStream = minimalConfig.withModifications {
+            element("incomingServer").remove()
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Missing 'incomingServer' element")
+    }
+
+    @Test
+    fun `config with missing 'outgoingServer' element should throw`() {
+        val inputStream = minimalConfig.withModifications {
+            element("outgoingServer").remove()
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Missing 'outgoingServer' element")
+    }
+
+    @Test
+    fun `incomingServer with missing hostname should throw`() {
+        val inputStream = minimalConfig.withModifications {
+            element("incomingServer > hostname").remove()
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Missing 'hostname' element")
+    }
+
+    @Test
+    fun `incomingServer with invalid hostname should throw`() {
+        val inputStream = minimalConfig.withModifications {
+            element("incomingServer > hostname").text("in valid")
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Invalid 'hostname' value: 'in valid'")
+    }
+
+    @Test
+    fun `incomingServer with missing port should throw`() {
+        val inputStream = minimalConfig.withModifications {
+            element("incomingServer > port").remove()
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Missing 'port' element")
+    }
+
+    @Test
+    fun `incomingServer with missing socketType should throw`() {
+        val inputStream = minimalConfig.withModifications {
+            element("incomingServer > socketType").remove()
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Missing 'socketType' element")
+    }
+
+    @Test
+    fun `incomingServer with missing authentication should throw`() {
+        val inputStream = minimalConfig.withModifications {
+            element("incomingServer > authentication").remove()
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("No usable 'authentication' element found")
+    }
+
+    @Test
+    fun `incomingServer with missing username should throw`() {
+        val inputStream = minimalConfig.withModifications {
+            element("incomingServer > username").remove()
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Missing 'username' element")
+    }
+
+    @Test
+    fun `incomingServer with invalid port should throw`() {
+        val inputStream = minimalConfig.withModifications {
+            element("incomingServer > port").text("invalid")
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Invalid 'port' value: 'invalid'")
+    }
+
+    @Test
+    fun `incomingServer with out of range port number should throw`() {
+        val inputStream = minimalConfig.withModifications {
+            element("incomingServer > port").text("100000")
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Invalid 'port' value: '100000'")
+    }
+
+    @Test
+    fun `incomingServer with unknown socketType should throw`() {
+        val inputStream = minimalConfig.withModifications {
+            element("incomingServer > socketType").text("TLS")
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Unknown 'socketType' value: 'TLS'")
+    }
+
+    @Test
+    fun `element found when expecting text should throw`() {
+        val inputStream = minimalConfig.withModifications {
+            element("incomingServer > hostname").html("imap.domain.example<element/>")
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Expected text, but got START_TAG")
+    }
+
+    @Test
+    fun `ignore 'incomingServer' and 'outgoingServer' inside wrong element`() {
+        val inputStream = minimalConfig.withModifications {
+            element("emailProvider").tagName("madeUpTag")
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Missing 'emailProvider' element")
+    }
+
+    @Test
+    fun `ignore 'incomingServer' inside unsupported 'incomingServer' element`() {
+        val inputStream = minimalConfig.withModifications {
+            val incomingServer = element("incomingServer")
+            val incomingServerXml = incomingServer.outerHtml()
+            incomingServer.attr("type", "unsupported")
+            incomingServer.html(incomingServerXml)
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Missing 'incomingServer' element")
+    }
+
+    @Test
+    fun `ignore 'outgoingServer' inside unsupported 'outgoingServer' element`() {
+        val inputStream = minimalConfig.withModifications {
+            val outgoingServer = element("outgoingServer")
+            val outgoingServerXml = outgoingServer.outerHtml()
+            outgoingServer.attr("type", "unsupported")
+            outgoingServer.html(outgoingServerXml)
+        }
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Missing 'outgoingServer' element")
+    }
+
+    @Test
+    fun `non XML data should throw`() {
+        val inputStream = "invalid".byteInputStream()
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Error parsing Autoconfig XML")
+    }
+
+    @Test
+    fun `wrong root element should throw`() {
+        @Language("XML")
+        val inputStream =
+            """
+            <?xml version="1.0" encoding="UTF-8"?>
+            <serverConfig></serverConfig>
+            """.trimIndent().byteInputStream()
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Missing 'clientConfig' element")
+    }
+
+    @Test
+    fun `syntactically incorrect XML should throw`() {
+        @Language("XML")
+        val inputStream =
+            """
+            <?xml version="1.0" encoding="UTF-8"?>
+            <clientConfig version="1.1">
+              <emailProvider id="domain.example">
+                <incomingServer type="imap">
+                  <hostname>imap.domain.example</hostname>
+                  <port>993</port>
+                  <socketType>SSL</socketType>
+                  <authentication>password-cleartext</authentication>
+                  <username>%EMAILADDRESS%</username>
+                </incomingServer>
+                <outgoingServer type="smtp">
+                  <hostname>smtp.domain.example</hostname>
+                  <port>465</port>
+                  <socketType>SSL</socketType>
+                  <authentication>password-cleartext</authentication>
+                  <username>%EMAILADDRESS%</username>
+                </outgoingServer>
+              <!-- Missing </emailProvider> -->
+            </clientConfig>
+            """.trimIndent().byteInputStream()
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("Error parsing Autoconfig XML")
+    }
+
+    @Test
+    fun `incomplete XML should throw`() {
+        @Language("XML")
+        val inputStream =
+            """
+            <?xml version="1.0"?>
+            <clientConfig version="1.1">
+              <emailProvider id="domain.example">
+            """.trimIndent().byteInputStream()
+
+        val result = parser.parseSettings(inputStream, irrelevantEmailAddress)
+
+        assertThat(result).isInstanceOf<ParserError>()
+            .prop(ParserError::error).hasMessage("End of document reached while reading element 'emailProvider'")
+    }
+
+    private fun String.withModifications(block: Document.() -> Unit): InputStream {
+        return Jsoup.parse(this, "", Parser.xmlParser())
+            .apply(block)
+            .toString()
+            .also {
+                if (PRINT_MODIFIED_XML) {
+                    println(it)
+                }
+            }
+            .byteInputStream()
+    }
+
+    private fun Document.element(query: String): Element {
+        return select(query).first() ?: error("Couldn't find element using '$query'")
+    }
+
+    private fun Element.insertBefore(xml: String) {
+        val index = siblingIndex()
+        parent()!!.apply {
+            append(xml)
+            val newElement = lastElementChild()!!
+            newElement.remove()
+            insertChildren(index, newElement)
+        }
+    }
+}
diff --git a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/RealSubDomainExtractorTest.kt b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/RealSubDomainExtractorTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..f7e65137aa496b36fc8bb7159c9af83a8261ff54
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/RealSubDomainExtractorTest.kt
@@ -0,0 +1,95 @@
+package app.k9mail.autodiscovery.autoconfig
+
+import app.k9mail.core.common.net.Domain
+import app.k9mail.core.common.net.toDomain
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.isNull
+import kotlin.test.Test
+
+class RealSubDomainExtractorTest {
+    private val testBaseDomainExtractor = TestBaseDomainExtractor(baseDomain = "domain.example")
+    private val baseSubDomainExtractor = RealSubDomainExtractor(testBaseDomainExtractor)
+
+    @Test
+    fun `input has one more label than the base domain`() {
+        val domain = "subdomain.domain.example".toDomain()
+
+        val result = baseSubDomainExtractor.extractSubDomain(domain)
+
+        assertThat(result).isEqualTo("domain.example".toDomain())
+    }
+
+    @Test
+    fun `input has two more labels than the base domain`() {
+        val domain = "more.subdomain.domain.example".toDomain()
+
+        val result = baseSubDomainExtractor.extractSubDomain(domain)
+
+        assertThat(result).isEqualTo("subdomain.domain.example".toDomain())
+    }
+
+    @Test
+    fun `input has three more labels than the base domain`() {
+        val domain = "three.two.one.domain.example".toDomain()
+
+        val result = baseSubDomainExtractor.extractSubDomain(domain)
+
+        assertThat(result).isEqualTo("two.one.domain.example".toDomain())
+    }
+
+    @Test
+    fun `no sub domain available`() {
+        val domain = "domain.example".toDomain()
+
+        val result = baseSubDomainExtractor.extractSubDomain(domain)
+
+        assertThat(result).isNull()
+    }
+
+    @Test
+    fun `input has one more label than the base domain with public suffix`() {
+        val domain = "subdomain.example.co.uk".toDomain()
+        testBaseDomainExtractor.baseDomain = "example.co.uk"
+
+        val result = baseSubDomainExtractor.extractSubDomain(domain)
+
+        assertThat(result).isEqualTo("example.co.uk".toDomain())
+    }
+
+    @Test
+    fun `input has two more labels than the base domain with public suffix`() {
+        val domain = "more.subdomain.example.co.uk".toDomain()
+        testBaseDomainExtractor.baseDomain = "example.co.uk"
+
+        val result = baseSubDomainExtractor.extractSubDomain(domain)
+
+        assertThat(result).isEqualTo("subdomain.example.co.uk".toDomain())
+    }
+
+    @Test
+    fun `input has three more labels than the base domain with public suffix`() {
+        val domain = "three.two.one.example.co.uk".toDomain()
+        testBaseDomainExtractor.baseDomain = "example.co.uk"
+
+        val result = baseSubDomainExtractor.extractSubDomain(domain)
+
+        assertThat(result).isEqualTo("two.one.example.co.uk".toDomain())
+    }
+
+    @Test
+    fun `no sub domain available with public suffix`() {
+        val domain = "example.co.uk".toDomain()
+        testBaseDomainExtractor.baseDomain = "example.co.uk"
+
+        val result = baseSubDomainExtractor.extractSubDomain(domain)
+
+        assertThat(result).isNull()
+    }
+}
+
+private class TestBaseDomainExtractor(var baseDomain: String) : BaseDomainExtractor {
+    override fun extractBaseDomain(domain: Domain): Domain {
+        return Domain(baseDomain)
+    }
+}
diff --git a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/ThunderbirdAutoconfigTest.kt b/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/ThunderbirdAutoconfigTest.kt
deleted file mode 100644
index cbd2114207e4b5cb3192644dcf2d0b367632cd02..0000000000000000000000000000000000000000
--- a/feature/autodiscovery/autoconfig/src/test/kotlin/app/k9mail/autodiscovery/autoconfig/ThunderbirdAutoconfigTest.kt
+++ /dev/null
@@ -1,174 +0,0 @@
-package app.k9mail.autodiscovery.autoconfig
-
-import app.k9mail.autodiscovery.api.DiscoveredServerSettings
-import app.k9mail.autodiscovery.api.DiscoveryResults
-import assertk.assertThat
-import assertk.assertions.isEqualTo
-import assertk.assertions.isNotNull
-import com.fsck.k9.mail.AuthType
-import com.fsck.k9.mail.ConnectionSecurity
-import org.junit.Test
-
-class ThunderbirdAutoconfigTest {
-    private val parser = AutoconfigParser()
-
-    @Test
-    fun settingsExtract() {
-        val input =
-            """
-            <?xml version="1.0"?>
-            <clientConfig version="1.1">
-                <emailProvider id="metacode.biz">
-                    <domain>metacode.biz</domain>
-    
-                    <incomingServer type="imap">
-                        <hostname>imap.googlemail.com</hostname>
-                        <port>993</port>
-                        <socketType>SSL</socketType>
-                        <username>%EMAILADDRESS%</username>
-                        <authentication>OAuth2</authentication>
-                        <authentication>password-cleartext</authentication>
-                    </incomingServer>
-    
-                    <outgoingServer type="smtp">
-                        <hostname>smtp.googlemail.com</hostname>
-                        <port>465</port>
-                        <socketType>SSL</socketType>
-                        <username>%EMAILADDRESS%</username>
-                        <authentication>OAuth2</authentication>
-                        <authentication>password-cleartext</authentication>
-                        <addThisServer>true</addThisServer>
-                    </outgoingServer>
-                </emailProvider>
-            </clientConfig>
-            """.trimIndent().byteInputStream()
-
-        val connectionSettings = parser.parseSettings(input, "test@metacode.biz")
-
-        assertThat(connectionSettings).isNotNull()
-        assertThat(connectionSettings!!.incoming).isNotNull()
-        assertThat(connectionSettings.outgoing).isNotNull()
-        with(connectionSettings.incoming.first()) {
-            assertThat(host).isEqualTo("imap.googlemail.com")
-            assertThat(port).isEqualTo(993)
-            assertThat(username).isEqualTo("test@metacode.biz")
-        }
-        with(connectionSettings.outgoing.first()) {
-            assertThat(host).isEqualTo("smtp.googlemail.com")
-            assertThat(port).isEqualTo(465)
-            assertThat(username).isEqualTo("test@metacode.biz")
-        }
-    }
-
-    @Test
-    fun multipleServers() {
-        val input =
-            """
-            <?xml version="1.0"?>
-            <clientConfig version="1.1">
-                <emailProvider id="metacode.biz">
-                    <domain>metacode.biz</domain>
-    
-                    <incomingServer type="imap">
-                        <hostname>imap.googlemail.com</hostname>
-                        <port>993</port>
-                        <socketType>SSL</socketType>
-                        <username>%EMAILADDRESS%</username>
-                        <authentication>OAuth2</authentication>
-                        <authentication>password-cleartext</authentication>
-                    </incomingServer>
-    
-                    <outgoingServer type="smtp">
-                        <hostname>first</hostname>
-                        <port>465</port>
-                        <socketType>SSL</socketType>
-                        <username>%EMAILADDRESS%</username>
-                        <authentication>OAuth2</authentication>
-                        <authentication>password-cleartext</authentication>
-                        <addThisServer>true</addThisServer>
-                    </outgoingServer>
-    
-                    <outgoingServer type="smtp">
-                        <hostname>second</hostname>
-                        <port>465</port>
-                        <socketType>SSL</socketType>
-                        <username>%EMAILADDRESS%</username>
-                        <authentication>OAuth2</authentication>
-                        <authentication>password-cleartext</authentication>
-                        <addThisServer>true</addThisServer>
-                    </outgoingServer>
-                </emailProvider>
-            </clientConfig>
-            """.trimIndent().byteInputStream()
-
-        val discoveryResults = parser.parseSettings(input, "test@metacode.biz")
-
-        assertThat(discoveryResults).isNotNull()
-        assertThat(discoveryResults!!.outgoing).isNotNull()
-        with(discoveryResults.outgoing[0]) {
-            assertThat(host).isEqualTo("first")
-            assertThat(port).isEqualTo(465)
-            assertThat(username).isEqualTo("test@metacode.biz")
-        }
-        with(discoveryResults.outgoing[1]) {
-            assertThat(host).isEqualTo("second")
-            assertThat(port).isEqualTo(465)
-            assertThat(username).isEqualTo("test@metacode.biz")
-        }
-    }
-
-    @Test
-    fun invalidResponse() {
-        val input =
-            """
-            <?xml version="1.0"?>
-                <clientConfig version="1.1">
-                    <emailProvider id="metacode.biz">
-                        <domain>metacode.biz</domain>
-            """.trimIndent().byteInputStream()
-
-        val connectionSettings = parser.parseSettings(input, "test@metacode.biz")
-
-        assertThat(connectionSettings).isEqualTo(DiscoveryResults(listOf(), listOf()))
-    }
-
-    @Test
-    fun incompleteConfiguration() {
-        val input =
-            """
-            <?xml version="1.0"?>
-            <clientConfig version="1.1">
-                <emailProvider id="metacode.biz">
-                    <domain>metacode.biz</domain>
-    
-                    <incomingServer type="imap">
-                        <hostname>imap.googlemail.com</hostname>
-                        <port>993</port>
-                        <socketType>SSL</socketType>
-                        <username>%EMAILADDRESS%</username>
-                        <authentication>OAuth2</authentication>
-                        <authentication>password-cleartext</authentication>
-                    </incomingServer>
-                </emailProvider>
-            </clientConfig>
-            """.trimIndent().byteInputStream()
-
-        val connectionSettings = parser.parseSettings(input, "test@metacode.biz")
-
-        assertThat(connectionSettings).isEqualTo(
-            DiscoveryResults(
-                listOf(
-                    DiscoveredServerSettings(
-                        protocol = "imap",
-                        host = "imap.googlemail.com",
-                        port = 993,
-                        security = ConnectionSecurity.SSL_TLS_REQUIRED,
-                        authType = AuthType.PLAIN,
-                        username = "test@metacode.biz",
-                    ),
-                ),
-                listOf(),
-            ),
-        )
-    }
-}
diff --git a/feature/autodiscovery/autoconfig/src/test/resources/2022-11-19-googlemail.com.xml b/feature/autodiscovery/autoconfig/src/test/resources/2022-11-19-googlemail.com.xml
new file mode 100644
index 0000000000000000000000000000000000000000..e0e7c383ad2e7b157c8b4ba51f71cdcc30459ee5
--- /dev/null
+++ b/feature/autodiscovery/autoconfig/src/test/resources/2022-11-19-googlemail.com.xml
@@ -0,0 +1,79 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<clientConfig version="1.1">
+  <emailProvider id="googlemail.com">
+    <domain>gmail.com</domain>
+    <domain>googlemail.com</domain>
+    <!-- MX, for Google Apps -->
+    <domain>google.com</domain>
+    <!-- HACK. Only add ISPs with 100000+ users here -->
+    <domain>jazztel.es</domain>
+
+    <displayName>Google Mail</displayName>
+    <displayShortName>GMail</displayShortName>
+
+    <incomingServer type="imap">
+      <hostname>imap.gmail.com</hostname>
+      <port>993</port>
+      <socketType>SSL</socketType>
+      <username>%EMAILADDRESS%</username>
+      <authentication>OAuth2</authentication>
+      <authentication>password-cleartext</authentication>
+    </incomingServer>
+    <incomingServer type="pop3">
+      <hostname>pop.gmail.com</hostname>
+      <port>995</port>
+      <socketType>SSL</socketType>
+      <username>%EMAILADDRESS%</username>
+      <authentication>OAuth2</authentication>
+      <authentication>password-cleartext</authentication>
+      <pop3>
+        <leaveMessagesOnServer>true</leaveMessagesOnServer>
+      </pop3>
+    </incomingServer>
+    <outgoingServer type="smtp">
+      <hostname>smtp.gmail.com</hostname>
+      <port>465</port>
+      <socketType>SSL</socketType>
+      <username>%EMAILADDRESS%</username>
+      <authentication>OAuth2</authentication>
+      <authentication>password-cleartext</authentication>
+    </outgoingServer>
+
+    <documentation url="http://mail.google.com/support/bin/answer.py?answer=13273">
+      <descr>How to enable IMAP/POP3 in GMail</descr>
+    </documentation>
+    <documentation url="http://mail.google.com/support/bin/topic.py?topic=12806">
+      <descr>How to configure email clients for IMAP</descr>
+    </documentation>
+    <documentation url="http://mail.google.com/support/bin/topic.py?topic=12805">
+      <descr>How to configure email clients for POP3</descr>
+    </documentation>
+    <documentation url="http://mail.google.com/support/bin/answer.py?answer=86399">
+      <descr>How to configure TB 2.0 for POP3</descr>
+    </documentation>
+  </emailProvider>
+
+  <oAuth2>
+    <issuer>accounts.google.com</issuer>
+    <!-- https://developers.google.com/identity/protocols/oauth2/scopes -->
+    <scope>https://mail.google.com/ https://www.googleapis.com/auth/contacts https://www.googleapis.com/auth/calendar https://www.googleapis.com/auth/carddav</scope>
+    <authURL>https://accounts.google.com/o/oauth2/auth</authURL>
+    <tokenURL>https://www.googleapis.com/oauth2/v3/token</tokenURL>
+  </oAuth2>
+
+  <enable visiturl="https://mail.google.com/mail/?ui=2&amp;shva=1#settings/fwdandpop">
+    <instruction>You need to enable IMAP access</instruction>
+  </enable>
+
+  <webMail>
+    <loginPage url="https://accounts.google.com/ServiceLogin?service=mail&amp;continue=http://mail.google.com/mail/" />
+    <loginPageInfo
+      url="https://accounts.google.com/ServiceLogin?service=mail&amp;continue=http://mail.google.com/mail/">
+      <username>%EMAILADDRESS%</username>
+      <usernameField id="Email" />
+      <passwordField id="Passwd" />
+      <loginButton id="signIn" />
+    </loginPageInfo>
+  </webMail>
+
+</clientConfig>
diff --git a/feature/autodiscovery/providersxml/build.gradle.kts b/feature/autodiscovery/providersxml/build.gradle.kts
index b83f1e14c375318855d30f7f6e05009e057df13b..32288d6a8d5fadab2e13a96195295fef837f7a39 100644
--- a/feature/autodiscovery/providersxml/build.gradle.kts
+++ b/feature/autodiscovery/providersxml/build.gradle.kts
@@ -3,13 +3,13 @@ plugins {
 }
 
 dependencies {
-    implementation(projects.app.core)
+    implementation(projects.core.common)
     implementation(projects.mail.common)
     implementation(projects.feature.autodiscovery.api)
 
     implementation(libs.timber)
 
-    testImplementation(projects.app.testing)
+    testImplementation(projects.core.android.testing)
     testImplementation(projects.backend.imap)
     testImplementation(libs.robolectric)
     testImplementation(libs.androidx.test.core)
diff --git a/feature/autodiscovery/providersxml/src/main/kotlin/app/k9mail/autodiscovery/providersxml/ProvidersXmlDiscovery.kt b/feature/autodiscovery/providersxml/src/main/kotlin/app/k9mail/autodiscovery/providersxml/ProvidersXmlDiscovery.kt
index 64d1ec820c1a472a06296f5ddb2aa582d1cd4953..3d9cba80f686701621eb20bb10fab17cc16f2372 100644
--- a/feature/autodiscovery/providersxml/src/main/kotlin/app/k9mail/autodiscovery/providersxml/ProvidersXmlDiscovery.kt
+++ b/feature/autodiscovery/providersxml/src/main/kotlin/app/k9mail/autodiscovery/providersxml/ProvidersXmlDiscovery.kt
@@ -5,11 +5,11 @@ import android.net.Uri
 import app.k9mail.autodiscovery.api.ConnectionSettingsDiscovery
 import app.k9mail.autodiscovery.api.DiscoveredServerSettings
 import app.k9mail.autodiscovery.api.DiscoveryResults
+import app.k9mail.core.common.mail.Protocols
+import app.k9mail.core.common.oauth.OAuthConfigurationProvider
 import com.fsck.k9.helper.EmailHelper
 import com.fsck.k9.mail.AuthType
 import com.fsck.k9.mail.ConnectionSecurity
-import com.fsck.k9.oauth.OAuthConfigurationProvider
-import com.fsck.k9.preferences.Protocols
 import org.xmlpull.v1.XmlPullParser
 import timber.log.Timber
 
diff --git a/feature/autodiscovery/providersxml/src/test/kotlin/app/k9mail/autodiscovery/providersxml/ProvidersXmlDiscoveryTest.kt b/feature/autodiscovery/providersxml/src/test/kotlin/app/k9mail/autodiscovery/providersxml/ProvidersXmlDiscoveryTest.kt
index 8957f5bed94f3a488a64fe9df8e4300d48a29a65..5f4432dd9600a22bda1750228dc401c7c77a4cf9 100644
--- a/feature/autodiscovery/providersxml/src/test/kotlin/app/k9mail/autodiscovery/providersxml/ProvidersXmlDiscoveryTest.kt
+++ b/feature/autodiscovery/providersxml/src/test/kotlin/app/k9mail/autodiscovery/providersxml/ProvidersXmlDiscoveryTest.kt
@@ -1,15 +1,15 @@
 package app.k9mail.autodiscovery.providersxml
 
 import androidx.test.core.app.ApplicationProvider
+import app.k9mail.core.android.testing.RobolectricTest
+import app.k9mail.core.common.oauth.OAuthConfiguration
+import app.k9mail.core.common.oauth.OAuthConfigurationProvider
 import assertk.assertThat
 import assertk.assertions.isEqualTo
 import assertk.assertions.isNotNull
 import assertk.assertions.isNull
-import com.fsck.k9.RobolectricTest
 import com.fsck.k9.mail.AuthType
 import com.fsck.k9.mail.ConnectionSecurity
-import com.fsck.k9.oauth.OAuthConfiguration
-import com.fsck.k9.oauth.OAuthConfigurationProvider
 import org.junit.Test
 
 class ProvidersXmlDiscoveryTest : RobolectricTest() {
@@ -46,19 +46,22 @@ class ProvidersXmlDiscoveryTest : RobolectricTest() {
     }
 
     private fun createOAuthConfigurationProvider(): OAuthConfigurationProvider {
-        val googleConfig = OAuthConfiguration(
-            clientId = "irrelevant",
-            scopes = listOf("irrelevant"),
-            authorizationEndpoint = "irrelevant",
-            tokenEndpoint = "irrelevant",
-            redirectUri = "irrelevant",
-        )
-
-        return OAuthConfigurationProvider(
-            configurations = mapOf(
-                listOf("imap.gmail.com", "smtp.gmail.com") to googleConfig,
-            ),
-            googleConfiguration = googleConfig,
-        )
+        return object : OAuthConfigurationProvider {
+            override fun getConfiguration(hostname: String): OAuthConfiguration? {
+                return when (hostname) {
+                    "imap.gmail.com" -> oAuthConfiguration
+                    "smtp.gmail.com" -> oAuthConfiguration
+                    else -> null
+                }
+            }
+        }
     }
+
+    private val oAuthConfiguration = OAuthConfiguration(
+        clientId = "irrelevant",
+        scopes = listOf("irrelevant"),
+        authorizationEndpoint = "irrelevant",
+        tokenEndpoint = "irrelevant",
+        redirectUri = "irrelevant",
+    )
 }
diff --git a/feature/autodiscovery/service/build.gradle.kts b/feature/autodiscovery/service/build.gradle.kts
new file mode 100644
index 0000000000000000000000000000000000000000..a7a4f7c0673ab0ae9756ffd4e45540499396f4d6
--- /dev/null
+++ b/feature/autodiscovery/service/build.gradle.kts
@@ -0,0 +1,13 @@
+plugins {
+    id(ThunderbirdPlugins.Library.jvm)
+    alias(libs.plugins.android.lint)
+}
+
+dependencies {
+    api(projects.feature.autodiscovery.autoconfig)
+
+    implementation(libs.kotlinx.coroutines.core)
+
+    testImplementation(libs.kotlinx.coroutines.test)
+    testImplementation(libs.kxml2)
+}
diff --git a/feature/autodiscovery/service/src/main/kotlin/app/k9mail/autodiscovery/service/PriorityParallelRunner.kt b/feature/autodiscovery/service/src/main/kotlin/app/k9mail/autodiscovery/service/PriorityParallelRunner.kt
new file mode 100644
index 0000000000000000000000000000000000000000..4e6b8225f1febc96b9833ee47fc795bf3ead6955
--- /dev/null
+++ b/feature/autodiscovery/service/src/main/kotlin/app/k9mail/autodiscovery/service/PriorityParallelRunner.kt
@@ -0,0 +1,82 @@
+package app.k9mail.autodiscovery.service
+
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult.NetworkError
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult.NoUsableSettingsFound
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult.Settings
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult.UnexpectedException
+import app.k9mail.autodiscovery.api.AutoDiscoveryRunnable
+import kotlin.coroutines.cancellation.CancellationException
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineStart.LAZY
+import kotlinx.coroutines.Deferred
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.coroutineScope
+
+/**
+ * Runs a list of [AutoDiscoveryRunnable]s with descending priority in parallel and returns the result with the highest
+ * priority.
+ *
+ * As soon as an [AutoDiscoveryRunnable] returns a [Settings] result, runnables with a lower priority are canceled.
+ */
+internal class PriorityParallelRunner(
+    private val runnables: List<AutoDiscoveryRunnable>,
+    private val coroutineDispatcher: CoroutineDispatcher = Dispatchers.IO,
+) {
+    suspend fun run(): AutoDiscoveryResult {
+        return coroutineScope {
+            val deferredList = buildList(capacity = runnables.size) {
+                // Create coroutines in reverse order. So ones with lower priority are created first.
+                for (runnable in runnables.reversed()) {
+                    val lowerPriorityCoroutines = toList()
+
+                    val deferred = async(coroutineDispatcher, start = LAZY) {
+                        runnable.run().also { discoveryResult ->
+                            if (discoveryResult is Settings) {
+                                // We've got a positive result, so cancel all coroutines with lower priority.
+                                lowerPriorityCoroutines.cancelAll()
+                            }
+                        }
+                    }
+
+                    add(deferred)
+                }
+            }.asReversed()
+
+            for (deferred in deferredList) {
+                deferred.start()
+            }
+
+            @Suppress("SwallowedException", "TooGenericExceptionCaught")
+            val discoveryResults = deferredList.map { deferred ->
+                try {
+                    deferred.await()
+                } catch (e: CancellationException) {
+                    null
+                } catch (e: Exception) {
+                    UnexpectedException(e)
+                }
+            }
+
+            val settingsResult = discoveryResults.firstOrNull { it is Settings }
+            if (settingsResult != null) {
+                settingsResult
+            } else {
+                val networkError = discoveryResults.firstOrNull { it is NetworkError }
+                val networkErrorCount = discoveryResults.count { it is NetworkError }
+                if (networkError != null && networkErrorCount == discoveryResults.size) {
+                    networkError
+                } else {
+                    NoUsableSettingsFound
+                }
+            }
+        }
+    }
+
+    private fun List<Deferred<AutoDiscoveryResult?>>.cancelAll() {
+        for (deferred in this) {
+            deferred.cancel()
+        }
+    }
+}
diff --git a/feature/autodiscovery/service/src/main/kotlin/app/k9mail/autodiscovery/service/RealAutoDiscoveryService.kt b/feature/autodiscovery/service/src/main/kotlin/app/k9mail/autodiscovery/service/RealAutoDiscoveryService.kt
new file mode 100644
index 0000000000000000000000000000000000000000..2e05ebeba61cdb5cd96ae15c6bbddcc14f5f39c3
--- /dev/null
+++ b/feature/autodiscovery/service/src/main/kotlin/app/k9mail/autodiscovery/service/RealAutoDiscoveryService.kt
@@ -0,0 +1,40 @@
+package app.k9mail.autodiscovery.service
+
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.autodiscovery.api.AutoDiscoveryService
+import app.k9mail.autodiscovery.autoconfig.AutoconfigUrlConfig
+import app.k9mail.autodiscovery.autoconfig.createIspDbAutoconfigDiscovery
+import app.k9mail.autodiscovery.autoconfig.createMxLookupAutoconfigDiscovery
+import app.k9mail.autodiscovery.autoconfig.createProviderAutoconfigDiscovery
+import app.k9mail.core.common.mail.EmailAddress
+import okhttp3.OkHttpClient
+
+/**
+ * Uses Thunderbird's Autoconfig mechanism to find mail server settings for a given email address.
+ */
+class RealAutoDiscoveryService(
+    private val okHttpClient: OkHttpClient,
+) : AutoDiscoveryService {
+
+    override suspend fun discover(email: EmailAddress): AutoDiscoveryResult {
+        val config = AutoconfigUrlConfig(
+            httpsOnly = false,
+            includeEmailAddress = false,
+        )
+
+        val providerDiscovery = createProviderAutoconfigDiscovery(okHttpClient, config)
+        val ispDbDiscovery = createIspDbAutoconfigDiscovery(okHttpClient)
+        val mxDiscovery = createMxLookupAutoconfigDiscovery(okHttpClient)
+
+        val runnables = listOf(
+            providerDiscovery,
+            ispDbDiscovery,
+            mxDiscovery,
+        ).flatMap { discovery ->
+            discovery.initDiscovery(email)
+        }
+
+        val runner = PriorityParallelRunner(runnables)
+        return runner.run()
+    }
+}
diff --git a/feature/autodiscovery/service/src/test/kotlin/app/k9mail/autodiscovery/service/PriorityParallelRunnerTest.kt b/feature/autodiscovery/service/src/test/kotlin/app/k9mail/autodiscovery/service/PriorityParallelRunnerTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..64ad0d0ebef5442caa2f9079548682d3d0d6fdc2
--- /dev/null
+++ b/feature/autodiscovery/service/src/test/kotlin/app/k9mail/autodiscovery/service/PriorityParallelRunnerTest.kt
@@ -0,0 +1,181 @@
+package app.k9mail.autodiscovery.service
+
+import app.k9mail.autodiscovery.api.AuthenticationType.PasswordCleartext
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult
+import app.k9mail.autodiscovery.api.AutoDiscoveryResult.NoUsableSettingsFound
+import app.k9mail.autodiscovery.api.AutoDiscoveryRunnable
+import app.k9mail.autodiscovery.api.ConnectionSecurity.StartTLS
+import app.k9mail.autodiscovery.api.ConnectionSecurity.TLS
+import app.k9mail.autodiscovery.api.ImapServerSettings
+import app.k9mail.autodiscovery.api.SmtpServerSettings
+import app.k9mail.core.common.net.toHostname
+import app.k9mail.core.common.net.toPort
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.isFalse
+import assertk.assertions.isNull
+import assertk.assertions.isTrue
+import kotlin.test.Test
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.StandardTestDispatcher
+import kotlinx.coroutines.test.runTest
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class PriorityParallelRunnerTest {
+    @Test
+    fun `first runnable returning a success result should cancel remaining runnables`() = runTest {
+        var runnableTwoStarted = false
+        var runnableThreeStarted = false
+        var runnableTwoCompleted = false
+        var runnableThreeCompleted = false
+        val runnableOne = AutoDiscoveryRunnable {
+            delay(100)
+            DISCOVERY_RESULT_ONE
+        }
+        val runnableTwo = AutoDiscoveryRunnable {
+            runnableTwoStarted = true
+            delay(200)
+            runnableTwoCompleted = true
+            DISCOVERY_RESULT_TWO
+        }
+        val runnableThree = AutoDiscoveryRunnable {
+            runnableThreeStarted = true
+            delay(200)
+            runnableThreeCompleted = false
+            DISCOVERY_RESULT_TWO
+        }
+        val runner = PriorityParallelRunner(
+            runnables = listOf(runnableOne, runnableTwo, runnableThree),
+            coroutineDispatcher = StandardTestDispatcher(testScheduler),
+        )
+
+        var result: AutoDiscoveryResult? = null
+        launch {
+            result = runner.run()
+        }
+
+        testScheduler.advanceTimeBy(50)
+
+        assertThat(result).isNull()
+        assertThat(runnableTwoStarted).isTrue()
+        assertThat(runnableTwoCompleted).isFalse()
+        assertThat(runnableThreeStarted).isTrue()
+        assertThat(runnableThreeCompleted).isFalse()
+
+        testScheduler.advanceUntilIdle()
+
+        assertThat(result).isEqualTo(DISCOVERY_RESULT_ONE)
+        assertThat(runnableTwoCompleted).isFalse()
+        assertThat(runnableThreeCompleted).isFalse()
+    }
+
+    @Test
+    fun `highest priority result should be used even if it takes longer to be produced`() = runTest {
+        var runnableTwoCompleted = false
+        val runnableOne = AutoDiscoveryRunnable {
+            delay(100)
+            DISCOVERY_RESULT_ONE
+        }
+        val runnableTwo = AutoDiscoveryRunnable {
+            runnableTwoCompleted = true
+            DISCOVERY_RESULT_TWO
+        }
+        val runner = PriorityParallelRunner(
+            runnables = listOf(runnableOne, runnableTwo),
+            coroutineDispatcher = StandardTestDispatcher(testScheduler),
+        )
+
+        var result: AutoDiscoveryResult? = null
+        launch {
+            result = runner.run()
+        }
+
+        testScheduler.advanceTimeBy(50)
+
+        assertThat(result).isNull()
+        assertThat(runnableTwoCompleted).isTrue()
+
+        testScheduler.advanceUntilIdle()
+
+        assertThat(result).isEqualTo(DISCOVERY_RESULT_ONE)
+    }
+
+    @Test
+    fun `wait for higher priority runnable to complete`() = runTest {
+        var runnableOneCompleted = false
+        var runnableTwoCompleted = false
+        val runnableOne = AutoDiscoveryRunnable {
+            delay(100)
+            runnableOneCompleted = true
+            NO_DISCOVERY_RESULT
+        }
+        val runnableTwo = AutoDiscoveryRunnable {
+            runnableTwoCompleted = true
+            DISCOVERY_RESULT_TWO
+        }
+        val runner = PriorityParallelRunner(
+            runnables = listOf(runnableOne, runnableTwo),
+            coroutineDispatcher = StandardTestDispatcher(testScheduler),
+        )
+
+        var result: AutoDiscoveryResult? = null
+        launch {
+            result = runner.run()
+        }
+
+        testScheduler.advanceTimeBy(50)
+
+        assertThat(result).isNull()
+        assertThat(runnableOneCompleted).isFalse()
+        assertThat(runnableTwoCompleted).isTrue()
+
+        testScheduler.advanceTimeBy(100)
+
+        assertThat(result).isEqualTo(DISCOVERY_RESULT_TWO)
+        assertThat(runnableOneCompleted).isTrue()
+    }
+
+    companion object {
+        private val NO_DISCOVERY_RESULT: AutoDiscoveryResult = NoUsableSettingsFound
+
+        private val DISCOVERY_RESULT_ONE = AutoDiscoveryResult.Settings(
+            ImapServerSettings(
+                hostname = "imap.domain.example".toHostname(),
+                port = 993.toPort(),
+                connectionSecurity = TLS,
+                authenticationTypes = listOf(PasswordCleartext),
+                username = "user@domain.example",
+            ),
+            SmtpServerSettings(
+                hostname = "smtp.domain.example".toHostname(),
+                port = 587.toPort(),
+                connectionSecurity = StartTLS,
+                authenticationTypes = listOf(PasswordCleartext),
+                username = "user@domain.example",
+            ),
+            isTrusted = true,
+            source = "result 1",
+        )
+
+        private val DISCOVERY_RESULT_TWO = AutoDiscoveryResult.Settings(
+            ImapServerSettings(
+                hostname = "imap.domain.example".toHostname(),
+                port = 143.toPort(),
+                connectionSecurity = StartTLS,
+                authenticationTypes = listOf(PasswordCleartext),
+                username = "user@domain.example",
+            ),
+            SmtpServerSettings(
+                hostname = "smtp.domain.example".toHostname(),
+                port = 465.toPort(),
+                connectionSecurity = TLS,
+                authenticationTypes = listOf(PasswordCleartext),
+                username = "user@domain.example",
+            ),
+            isTrusted = true,
+            source = "result 2",
+        )
+    }
+}
diff --git a/feature/autodiscovery/srvrecords/src/test/kotlin/app/k9mail/autodiscovery/srvrecords/SrvServiceDiscoveryTest.kt b/feature/autodiscovery/srvrecords/src/test/kotlin/app/k9mail/autodiscovery/srvrecords/SrvServiceDiscoveryTest.kt
index 8656aa59cfe619ed965ed8752435aab62d589cd8..4f14836b36bd2fa2e767189a579c6b4c47aa4348 100644
--- a/feature/autodiscovery/srvrecords/src/test/kotlin/app/k9mail/autodiscovery/srvrecords/SrvServiceDiscoveryTest.kt
+++ b/feature/autodiscovery/srvrecords/src/test/kotlin/app/k9mail/autodiscovery/srvrecords/SrvServiceDiscoveryTest.kt
@@ -1,8 +1,15 @@
 package app.k9mail.autodiscovery.srvrecords
 
 import app.k9mail.autodiscovery.api.DiscoveryResults
+import assertk.all
+import assertk.assertThat
+import assertk.assertions.containsExactly
+import assertk.assertions.extracting
+import assertk.assertions.hasSize
+import assertk.assertions.isEqualTo
+import assertk.assertions.isNotNull
+import assertk.assertions.prop
 import com.fsck.k9.mail.ConnectionSecurity
-import org.junit.Assert.assertEquals
 import org.junit.Test
 import org.mockito.kotlin.doReturn
 import org.mockito.kotlin.mock
@@ -16,7 +23,7 @@ class SrvServiceDiscoveryTest {
         val srvServiceDiscovery = SrvServiceDiscovery(srvResolver)
         val result = srvServiceDiscovery.discover("test@example.com")
 
-        assertEquals(DiscoveryResults(listOf(), listOf()), result)
+        assertThat(result).isEqualTo(DiscoveryResults(incoming = listOf(), outgoing = listOf()))
     }
 
     @Test
@@ -31,8 +38,10 @@ class SrvServiceDiscoveryTest {
         val srvServiceDiscovery = SrvServiceDiscovery(srvResolver)
         val result = srvServiceDiscovery.discover("test@example.com")
 
-        assertEquals(2, result!!.incoming.size)
-        assertEquals(0, result.outgoing.size)
+        assertThat(result).isNotNull().all {
+            prop(DiscoveryResults::incoming).hasSize(2)
+            prop(DiscoveryResults::outgoing).hasSize(0)
+        }
     }
 
     @Test
@@ -55,8 +64,10 @@ class SrvServiceDiscoveryTest {
         val srvServiceDiscovery = SrvServiceDiscovery(srvResolver)
         val result = srvServiceDiscovery.discover("test@example.com")
 
-        assertEquals(0, result!!.incoming.size)
-        assertEquals(2, result.outgoing.size)
+        assertThat(result).isNotNull().all {
+            prop(DiscoveryResults::incoming).hasSize(0)
+            prop(DiscoveryResults::outgoing).hasSize(2)
+        }
     }
 
     @Test
@@ -131,24 +142,20 @@ class SrvServiceDiscoveryTest {
         val srvServiceDiscovery = SrvServiceDiscovery(srvResolver)
         val result = srvServiceDiscovery.discover("test@example.com")
 
-        assertEquals(
-            listOf(
+        assertThat(result).isNotNull().all {
+            prop(DiscoveryResults::outgoing).extracting { it.host }.containsExactly(
                 "smtp3.example.com",
                 "smtp1.example.com",
                 "smtp4.example.com",
                 "smtp2.example.com",
-            ),
-            result?.outgoing?.map { it.host },
-        )
-        assertEquals(
-            listOf(
+            )
+            prop(DiscoveryResults::incoming).extracting { it.host }.containsExactly(
                 "imaps1.example.com",
                 "imap1.example.com",
                 "imaps2.example.com",
                 "imap2.example.com",
-            ),
-            result?.incoming?.map { it.host },
-        )
+            )
+        }
     }
 
     private fun newMailService(
diff --git a/feature/launcher/build.gradle.kts b/feature/launcher/build.gradle.kts
new file mode 100644
index 0000000000000000000000000000000000000000..ed6f16361add6e2ee969d4722893ac866237f7f1
--- /dev/null
+++ b/feature/launcher/build.gradle.kts
@@ -0,0 +1,25 @@
+plugins {
+    id(ThunderbirdPlugins.Library.androidCompose)
+}
+
+android {
+    namespace = "app.k9mail.feature.launcher"
+    resourcePrefix = "launcher_"
+
+    buildTypes {
+        debug {
+            manifestPlaceholders["appAuthRedirectScheme"] = "FIXME: override this in your app project"
+        }
+        release {
+            manifestPlaceholders["appAuthRedirectScheme"] = "FIXME: override this in your app project"
+        }
+    }
+}
+
+dependencies {
+    implementation(projects.core.ui.compose.designsystem)
+    implementation(projects.feature.onboarding)
+    implementation(projects.feature.account.setup)
+
+    testImplementation(projects.core.ui.compose.testing)
+}
diff --git a/feature/launcher/src/main/AndroidManifest.xml b/feature/launcher/src/main/AndroidManifest.xml
new file mode 100644
index 0000000000000000000000000000000000000000..f3051e0d187b3a2e07230b890d6ba312a635b846
--- /dev/null
+++ b/feature/launcher/src/main/AndroidManifest.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <application android:supportsRtl="true">
+
+        <activity
+            android:name=".FeatureLauncherActivity"
+            android:windowSoftInputMode="adjustResize"
+            />
+
+    </application>
+
+</manifest>
diff --git a/feature/launcher/src/main/kotlin/app/k9mail/feature/launcher/FeatureLauncherActivity.kt b/feature/launcher/src/main/kotlin/app/k9mail/feature/launcher/FeatureLauncherActivity.kt
new file mode 100644
index 0000000000000000000000000000000000000000..fe1be03d4cd558111b3084a4140fdf1bf873dd03
--- /dev/null
+++ b/feature/launcher/src/main/kotlin/app/k9mail/feature/launcher/FeatureLauncherActivity.kt
@@ -0,0 +1,49 @@
+package app.k9mail.feature.launcher
+
+import android.app.Activity
+import android.content.Intent
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.core.view.WindowCompat
+import app.k9mail.core.ui.compose.common.activity.setActivityContent
+import app.k9mail.feature.account.setup.navigation.NAVIGATION_ROUTE_ACCOUNT_SETUP
+import app.k9mail.feature.launcher.ui.FeatureLauncherApp
+import app.k9mail.feature.onboarding.navigation.NAVIGATION_ROUTE_ONBOARDING
+
+class FeatureLauncherActivity : ComponentActivity() {
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        WindowCompat.setDecorFitsSystemWindows(window, false)
+
+        val destination = intent.getStringExtra(EXTRA_DESTINATION)
+
+        setActivityContent {
+            FeatureLauncherApp(startDestination = destination)
+        }
+    }
+
+    companion object {
+        private const val EXTRA_DESTINATION = "destination"
+        private const val DESTINATION_ONBOARDING = NAVIGATION_ROUTE_ONBOARDING
+        private const val DESTINATION_SETUP_ACCOUNT = NAVIGATION_ROUTE_ACCOUNT_SETUP
+
+        @JvmStatic
+        fun launchOnboarding(context: Activity) {
+            val intent = Intent(context, FeatureLauncherActivity::class.java).apply {
+                putExtra(EXTRA_DESTINATION, DESTINATION_ONBOARDING)
+                flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK
+            }
+            context.startActivity(intent)
+        }
+
+        @JvmStatic
+        fun launchSetupAccount(context: Activity) {
+            val intent = Intent(context, FeatureLauncherActivity::class.java).apply {
+                putExtra(EXTRA_DESTINATION, DESTINATION_SETUP_ACCOUNT)
+            }
+            context.startActivity(intent)
+        }
+    }
+}
diff --git a/feature/launcher/src/main/kotlin/app/k9mail/feature/launcher/FeatureLauncherExternalContract.kt b/feature/launcher/src/main/kotlin/app/k9mail/feature/launcher/FeatureLauncherExternalContract.kt
new file mode 100644
index 0000000000000000000000000000000000000000..57fdbefb2cd1cc72dd2f43e820f2ab5e21b20ebe
--- /dev/null
+++ b/feature/launcher/src/main/kotlin/app/k9mail/feature/launcher/FeatureLauncherExternalContract.kt
@@ -0,0 +1,12 @@
+package app.k9mail.feature.launcher
+
+interface FeatureLauncherExternalContract {
+
+    fun interface AccountSetupFinishedLauncher {
+        fun launch(accountUuid: String)
+    }
+
+    fun interface ImportSettingsLauncher {
+        fun launch()
+    }
+}
diff --git a/feature/launcher/src/main/kotlin/app/k9mail/feature/launcher/di/FeatureLauncherModule.kt b/feature/launcher/src/main/kotlin/app/k9mail/feature/launcher/di/FeatureLauncherModule.kt
new file mode 100644
index 0000000000000000000000000000000000000000..7cc641f17b5f920819bf41616928239c4babdaf5
--- /dev/null
+++ b/feature/launcher/src/main/kotlin/app/k9mail/feature/launcher/di/FeatureLauncherModule.kt
@@ -0,0 +1,10 @@
+package app.k9mail.feature.launcher.di
+
+import app.k9mail.feature.account.setup.featureAccountSetupModule
+import org.koin.dsl.module
+
+val featureLauncherModule = module {
+    includes(
+        featureAccountSetupModule,
+    )
+}
diff --git a/feature/launcher/src/main/kotlin/app/k9mail/feature/launcher/navigation/FeatureLauncherNavHost.kt b/feature/launcher/src/main/kotlin/app/k9mail/feature/launcher/navigation/FeatureLauncherNavHost.kt
new file mode 100644
index 0000000000000000000000000000000000000000..a5b78510fe371947be86e9cc1ebf8353361528d1
--- /dev/null
+++ b/feature/launcher/src/main/kotlin/app/k9mail/feature/launcher/navigation/FeatureLauncherNavHost.kt
@@ -0,0 +1,38 @@
+package app.k9mail.feature.launcher.navigation
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.navigation.NavHostController
+import androidx.navigation.compose.NavHost
+import app.k9mail.feature.account.setup.navigation.accountSetupRoute
+import app.k9mail.feature.account.setup.navigation.navigateToAccountSetup
+import app.k9mail.feature.launcher.FeatureLauncherExternalContract.AccountSetupFinishedLauncher
+import app.k9mail.feature.launcher.FeatureLauncherExternalContract.ImportSettingsLauncher
+import app.k9mail.feature.onboarding.navigation.NAVIGATION_ROUTE_ONBOARDING
+import app.k9mail.feature.onboarding.navigation.onboardingRoute
+import org.koin.compose.koinInject
+
+@Composable
+fun FeatureLauncherNavHost(
+    navController: NavHostController,
+    startDestination: String?,
+    onBack: () -> Unit,
+    modifier: Modifier = Modifier,
+    importSettingsLauncher: ImportSettingsLauncher = koinInject(),
+    accountSetupFinishedLauncher: AccountSetupFinishedLauncher = koinInject(),
+) {
+    NavHost(
+        navController = navController,
+        startDestination = startDestination ?: NAVIGATION_ROUTE_ONBOARDING,
+        modifier = modifier,
+    ) {
+        onboardingRoute(
+            onStart = { navController.navigateToAccountSetup() },
+            onImport = { importSettingsLauncher.launch() },
+        )
+        accountSetupRoute(
+            onBack = onBack,
+            onFinish = { accountSetupFinishedLauncher.launch(it) },
+        )
+    }
+}
diff --git a/feature/launcher/src/main/kotlin/app/k9mail/feature/launcher/ui/FeatureLauncherApp.kt b/feature/launcher/src/main/kotlin/app/k9mail/feature/launcher/ui/FeatureLauncherApp.kt
new file mode 100644
index 0000000000000000000000000000000000000000..0bafc94ec02854092bbcefb7b0ca2a994f9c949b
--- /dev/null
+++ b/feature/launcher/src/main/kotlin/app/k9mail/feature/launcher/ui/FeatureLauncherApp.kt
@@ -0,0 +1,36 @@
+package app.k9mail.feature.launcher.ui
+
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.safeDrawingPadding
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.navigation.compose.rememberNavController
+import app.k9mail.core.ui.compose.common.activity.LocalActivity
+import app.k9mail.core.ui.compose.designsystem.atom.Background
+import app.k9mail.core.ui.compose.theme.K9Theme
+import app.k9mail.feature.launcher.navigation.FeatureLauncherNavHost
+
+@Composable
+fun FeatureLauncherApp(
+    startDestination: String?,
+    modifier: Modifier = Modifier,
+) {
+    val navController = rememberNavController()
+
+    K9Theme {
+        Background(
+            modifier = Modifier
+                .fillMaxSize()
+                .safeDrawingPadding()
+                .then(modifier),
+        ) {
+            val activity = LocalActivity.current
+
+            FeatureLauncherNavHost(
+                navController = navController,
+                startDestination = startDestination,
+                onBack = { activity.finish() },
+            )
+        }
+    }
+}
diff --git a/feature/onboarding/src/main/kotlin/app/k9mail/feature/onboarding/navigation/OnboardingNavigation.kt b/feature/onboarding/src/main/kotlin/app/k9mail/feature/onboarding/navigation/OnboardingNavigation.kt
index 72658cb47bca8e0460ed0af44aac5353ddc349af..86a700e1bb2e056224b87a43bb75dcf9d140b140 100644
--- a/feature/onboarding/src/main/kotlin/app/k9mail/feature/onboarding/navigation/OnboardingNavigation.kt
+++ b/feature/onboarding/src/main/kotlin/app/k9mail/feature/onboarding/navigation/OnboardingNavigation.kt
@@ -14,14 +14,14 @@ fun NavController.navigateToOnboarding(
     navigate(NAVIGATION_ROUTE_ONBOARDING, navOptions)
 }
 
-fun NavGraphBuilder.onboardingScreen(
-    onStartClick: () -> Unit,
-    onImportClick: () -> Unit,
+fun NavGraphBuilder.onboardingRoute(
+    onStart: () -> Unit,
+    onImport: () -> Unit,
 ) {
     composable(route = NAVIGATION_ROUTE_ONBOARDING) {
         OnboardingScreen(
-            onStartClick = onStartClick,
-            onImportClick = onImportClick,
+            onStartClick = onStart,
+            onImportClick = onImport,
         )
     }
 }
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 2985c41408ee39b8f7117ae6076a98ec92beb328..531b1cb6b601cef7bacb14972dab957a0c17c586 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -3,50 +3,52 @@
 
 [versions]
 gradle = "8.1.1"
-androidGradlePlugin = "8.0.1"
+androidGradlePlugin = "8.0.2"
 ktlint = "0.48.2"
 
-kotlin = "1.8.20"
-kotlinxCoroutines = "1.6.4"
+kotlin = "1.8.21"
+kotlinxCoroutines = "1.7.1"
 jetbrainsAnnotations = "24.0.1"
 androidxAppCompat = "1.6.1"
-androidxActivity = "1.7.1"
+androidxActivity = "1.7.2"
 androidxRecyclerView = "1.3.0"
 androidxLifecycle = "2.6.1"
-androidxNavigation = "2.5.3"
+androidxNavigation = "2.6.0"
 androidxConstraintLayout = "2.1.4"
-androidxFragment = "1.5.6"
-androidxCore = "1.10.0"
+androidxFragment = "1.6.0"
+androidxCore = "1.10.1"
 androidxCoreSplashscreen = "1.0.1"
 androidxPreference = "1.2.0"
 androidxDrawerLayout = "1.1.1"
 androidxTransition = "1.4.1"
-androidxComposeCompiler = "1.4.6"
-androidxComposeBom = "2023.04.01"
-androidxComposeMaterial = "1.3.1"
+androidxComposeCompiler = "1.4.7"
+androidxComposeBom = "2023.05.01"
+androidxComposeMaterial = "1.4.3"
 accompanist = "0.30.1"
 fastAdapter = "5.7.0"
 preferencesFix = "1.1.0"
 timber = "5.0.1"
-koinCore = "3.4.0"
-koinAndroid = "3.4.0"
+koinCore = "3.4.2"
+koinAndroid = "3.4.2"
+koinAndroidCompose = "3.4.5"
+koinTest = "3.4.1"
 mime4j = "0.8.9"
-okhttp = "4.10.0"
+okhttp = "4.11.0"
 glide = "4.15.1"
-moshi = "1.14.0"
-datastore = "1.0.0"
+moshi = "1.15.0"
 mockito = "5.3.1"
+datastore = "1.0.0"
 
 [plugins]
-android-application = { id = "com.android.application", version = "8.0.0" }
-android-library = { id = "com.android.library", version = "8.0.0" }
-android-lint = { id = "com.android.lint", version = "8.0.0" }
-ksp = "com.google.devtools.ksp:1.8.20-1.0.11"
+android-application = { id = "com.android.application", version.ref = "androidGradlePlugin" }
+android-library = { id = "com.android.library", version.ref = "androidGradlePlugin" }
+android-lint = { id = "com.android.lint", version.ref = "androidGradlePlugin" }
+ksp = "com.google.devtools.ksp:1.8.21-1.0.11"
 kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
 kotlin-parcelize = { id = "org.jetbrains.kotlin.plugin.parcelize", version.ref = "kotlin" }
 kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
 spotless = "com.diffplug.spotless:6.14.0"
-detekt = "io.gitlab.arturbosch.detekt:1.22.0"
+detekt = "io.gitlab.arturbosch.detekt:1.23.0"
 dependency-check = "com.github.ben-manes.versions:0.46.0"
 
 [libraries]
@@ -58,6 +60,7 @@ kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-c
 kotlinx-coroutines-android = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-android", version.ref = "kotlinxCoroutines" }
 kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "kotlinxCoroutines" }
 kotlinx-datetime = "org.jetbrains.kotlinx:kotlinx-datetime:0.4.0"
+kotlinx-collections-immutable = "org.jetbrains.kotlinx:kotlinx-collections-immutable:0.3.5"
 jetbrains-annotations = { module = "org.jetbrains:annotations", version.ref = "jetbrainsAnnotations" }
 androidx-appcompat = { module = "androidx.appcompat:appcompat", version.ref = "androidxAppCompat" }
 androidx-activity = { module = "androidx.activity:activity", version.ref = "androidxActivity" }
@@ -88,6 +91,7 @@ androidx-compose-ui-tooling-preview = { module = "androidx.compose.ui:ui-tooling
 androidx-compose-ui-test-manifest = { module = "androidx.compose.ui:ui-test-manifest" }
 androidx-compose-ui-test-junit4 = { module = "androidx.compose.ui:ui-test-junit4" }
 androidx-compose-activity = { module = "androidx.activity:activity-compose", version.ref = "androidxActivity" }
+androidx-compose-lifecycle-runtime = { module = "androidx.lifecycle:lifecycle-runtime-compose", version.ref = "androidxLifecycle" }
 androidx-compose-lifecycle-viewmodel = { module = "androidx.lifecycle:lifecycle-viewmodel-compose", version.ref = "androidxLifecycle" }
 androidx-compose-material = { module = "androidx.compose.material:material", version.ref = "androidxComposeMaterial" }
 androidx-compose-material-icons-extended = { module = "androidx.compose.material:material-icons-extended", version.ref = "androidxComposeMaterial" }
@@ -96,7 +100,7 @@ androidx-test-core = "androidx.test:core:1.5.0"
 androidx-datastore = { module = "androidx.datastore:datastore-preferences", version.ref = "datastore" }
 androidx-test-ext-junit-ktx = "androidx.test.ext:junit-ktx:1.1.5"
 androidx-test-espresso-core = "androidx.test.espresso:espresso-core:3.5.1"
-android-material = "com.google.android.material:material:1.8.0"
+android-material = "com.google.android.material:material:1.9.0"
 accompanist-systemuicontroller = { module = "com.google.accompanist:accompanist-systemuicontroller", version.ref = "accompanist" }
 fastadapter = { module = "com.mikepenz:fastadapter", version.ref = "fastAdapter" }
 fastadapter-extensions-drag = { module = "com.mikepenz:fastadapter-extensions-drag", version.ref = "fastAdapter" }
@@ -113,8 +117,9 @@ gson = "com.google.code.gson:gson:2.8.9"
 timber = "com.jakewharton.timber:timber:5.0.1"
 koin-core = { module = "io.insert-koin:koin-core", version.ref = "koinCore" }
 koin-android = { module = "io.insert-koin:koin-android", version.ref = "koinAndroid" }
-koin-test = { module = "io.insert-koin:koin-test", version.ref = "koinCore" }
-koin-test-junit4 = { module = "io.insert-koin:koin-test-junit4", version.ref = "koinCore" }
+koin-androidx-compose = { module = "io.insert-koin:koin-androidx-compose", version.ref = "koinAndroidCompose" }
+koin-test = { module = "io.insert-koin:koin-test", version.ref = "koinTest" }
+koin-test-junit4 = { module = "io.insert-koin:koin-test-junit4", version.ref = "koinTest" }
 commons-io = "commons-io:commons-io:2.11.0"
 mime4j-core = { module = "org.apache.james:apache-mime4j-core", version.ref = "mime4j" }
 mime4j-dom = { module = "org.apache.james:apache-mime4j-dom", version.ref = "mime4j" }
@@ -149,14 +154,14 @@ junit = "junit:junit:4.13.2"
 robolectric = "org.robolectric:robolectric:4.9.2"
 mockito-core = { module = "org.mockito:mockito-core", version.ref = "mockito" }
 mockito-kotlin = "org.mockito.kotlin:mockito-kotlin:4.1.0"
-turbine = "app.cash.turbine:turbine:0.12.3"
+turbine = "app.cash.turbine:turbine:0.13.0"
 jdom2 = "org.jdom:jdom2:2.0.6.1"
 icu4j-charset = "com.ibm.icu:icu4j-charset:72.1"
-assertk = "com.willowtreeapps.assertk:assertk-jvm:0.25"
+assertk = "com.willowtreeapps.assertk:assertk-jvm:0.26.1"
 
 leakcanary-android = "com.squareup.leakcanary:leakcanary-android:2.9.1"
 
-detekt-plugin-compose = "io.nlopez.compose.rules:detekt:0.1.1"
+detekt-plugin-compose = "io.nlopez.compose.rules:detekt:0.1.7"
 
 [bundles]
 shared-jvm-main = [
@@ -174,10 +179,13 @@ shared-jvm-android-app = [
   "android-material",
 ]
 shared-jvm-android-compose = [
+  "kotlinx-collections-immutable",
   "androidx-compose-foundation",
   "androidx-compose-ui-tooling-preview",
+  "androidx-compose-lifecycle-runtime",
   "androidx-compose-lifecycle-viewmodel",
   "androidx-compose-navigation",
+  "koin-androidx-compose",
 ]
 shared-jvm-android-compose-debug = [
   "androidx-compose-ui-tooling",
@@ -187,12 +195,14 @@ shared-jvm-androidtest-compose = [
   "androidx-compose-ui-test-junit4",
 ]
 shared-jvm-test = [
+  "kotlin-test",
   "junit",
   "assertk",
   "mockito-core",
   "mockito-kotlin",
   "koin-test",
   "koin-test-junit4",
+  "turbine",
 ]
 shared-jvm-test-compose = [
   "robolectric",
diff --git a/mail/common/src/main/java/com/fsck/k9/mail/Address.java b/mail/common/src/main/java/com/fsck/k9/mail/Address.java
index fd272638fa22fea133a8fa0ad91291bee67afa24..8bc3eaa1d22ba000bbfbb9eefd9f9e0e6c33548c 100644
--- a/mail/common/src/main/java/com/fsck/k9/mail/Address.java
+++ b/mail/common/src/main/java/com/fsck/k9/mail/Address.java
@@ -115,7 +115,8 @@ public class Address implements Serializable {
             for (Rfc822Token token : tokens) {
                 String address = token.getAddress();
                 if (!TextUtils.isEmpty(address)) {
-                    addresses.add(new Address(token.getAddress(), token.getName(), false));
+                    String name = TextUtils.isEmpty(token.getName()) ? null : token.getName();
+                    addresses.add(new Address(token.getAddress(), name, false));
                 }
             }
         }
diff --git a/mail/common/src/main/java/com/fsck/k9/mail/ServerSettings.kt b/mail/common/src/main/java/com/fsck/k9/mail/ServerSettings.kt
index 9be006f679d11a274d9ee38192552037a68d2db1..28707a7327eb81b75cc28b62d1a0c8376b6b3639 100644
--- a/mail/common/src/main/java/com/fsck/k9/mail/ServerSettings.kt
+++ b/mail/common/src/main/java/com/fsck/k9/mail/ServerSettings.kt
@@ -16,6 +16,7 @@ data class ServerSettings @JvmOverloads constructor(
 ) {
     val isMissingCredentials: Boolean = when (authenticationType) {
         AuthType.EXTERNAL -> clientCertificateAlias == null
+        AuthType.XOAUTH2 -> username.isBlank()
         else -> username.isNotBlank() && password == null
     }
 
diff --git a/mail/common/src/main/java/com/fsck/k9/mail/filter/FixedLengthInputStream.java b/mail/common/src/main/java/com/fsck/k9/mail/filter/FixedLengthInputStream.java
deleted file mode 100644
index 9535822e0001f01929b6866ec6ede96e709b163a..0000000000000000000000000000000000000000
--- a/mail/common/src/main/java/com/fsck/k9/mail/filter/FixedLengthInputStream.java
+++ /dev/null
@@ -1,78 +0,0 @@
-
-package com.fsck.k9.mail.filter;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.Locale;
-
-/**
- * A filtering InputStream that stops allowing reads after the given length has been read. This
- * is used to allow a client to read directly from an underlying protocol stream without reading
- * past where the protocol handler intended the client to read.
- */
-public class FixedLengthInputStream extends InputStream {
-    private final InputStream mIn;
-    private final int mLength;
-    private int mCount = 0;
-
-    public FixedLengthInputStream(InputStream in, int length) {
-        this.mIn = in;
-        this.mLength = length;
-    }
-
-    @Override
-    public int available() throws IOException {
-        return mLength - mCount;
-    }
-
-    @Override
-    public int read() throws IOException {
-        if (mCount >= mLength) {
-            return -1;
-        }
-
-        int d = mIn.read();
-        if (d != -1) {
-            mCount++;
-        }
-        return d;
-    }
-
-    @Override
-    public int read(byte[] b, int offset, int length) throws IOException {
-        if (mCount >= mLength) {
-            return -1;
-        }
-
-        int d = mIn.read(b, offset, Math.min(mLength - mCount, length));
-        if (d != -1) {
-            mCount += d;
-        }
-        return d;
-    }
-
-    @Override
-    public int read(byte[] b) throws IOException {
-        return read(b, 0, b.length);
-    }
-
-    @Override
-    public long skip(long n) throws IOException {
-        long d = mIn.skip(Math.min(n, available()));
-        if (d > 0) {
-            mCount += d;
-        }
-        return d;
-    }
-
-    @Override
-    public String toString() {
-        return String.format(Locale.US, "FixedLengthInputStream(in=%s, length=%d)", mIn.toString(), mLength);
-    }
-
-    public void skipRemaining() throws IOException {
-        while (available() > 0) {
-            skip(available());
-        }
-    }
-}
diff --git a/mail/common/src/main/java/com/fsck/k9/mail/filter/FixedLengthInputStream.kt b/mail/common/src/main/java/com/fsck/k9/mail/filter/FixedLengthInputStream.kt
new file mode 100644
index 0000000000000000000000000000000000000000..a3e4071035ac8d9e227151efa4970201f1923b43
--- /dev/null
+++ b/mail/common/src/main/java/com/fsck/k9/mail/filter/FixedLengthInputStream.kt
@@ -0,0 +1,80 @@
+package com.fsck.k9.mail.filter
+
+import java.io.IOException
+import java.io.InputStream
+import java.util.Locale
+import org.apache.commons.io.IOUtils
+
+/**
+ * A filtering InputStream that stops allowing reads after the given length has been read. This
+ * is used to allow a client to read directly from an underlying protocol stream without reading
+ * past where the protocol handler intended the client to read.
+ */
+class FixedLengthInputStream(
+    private val inputStream: InputStream,
+    private val length: Int,
+) : InputStream() {
+    private var numberOfBytesRead = 0
+
+    // TODO: Call available() on underlying InputStream if remainingBytes() > 0
+    @Throws(IOException::class)
+    override fun available(): Int {
+        return remainingBytes()
+    }
+
+    @Throws(IOException::class)
+    override fun read(): Int {
+        if (remainingBytes() == 0) {
+            return -1
+        }
+
+        val byte = inputStream.read()
+        if (byte != -1) {
+            numberOfBytesRead++
+        }
+
+        return byte
+    }
+
+    @Throws(IOException::class)
+    override fun read(b: ByteArray, offset: Int, length: Int): Int {
+        if (remainingBytes() == 0) {
+            return -1
+        }
+
+        val byte = inputStream.read(b, offset, length.coerceAtMost(remainingBytes()))
+        if (byte != -1) {
+            numberOfBytesRead += byte
+        }
+
+        return byte
+    }
+
+    @Throws(IOException::class)
+    override fun read(b: ByteArray): Int {
+        return read(b, 0, b.size)
+    }
+
+    @Throws(IOException::class)
+    override fun skip(n: Long): Long {
+        val numberOfSkippedBytes = inputStream.skip(n.coerceAtMost(remainingBytes().toLong()))
+        if (numberOfSkippedBytes > 0) {
+            numberOfBytesRead += numberOfSkippedBytes.toInt()
+        }
+
+        return numberOfSkippedBytes
+    }
+
+    @Throws(IOException::class)
+    fun skipRemaining() {
+        IOUtils.skipFully(this, remainingBytes().toLong())
+    }
+
+    private fun remainingBytes(): Int {
+        return length - numberOfBytesRead
+    }
+
+    override fun toString(): String {
+        return String.format(Locale.ROOT, "FixedLengthInputStream(in=%s, length=%d)", inputStream.toString(), length)
+    }
+}
diff --git a/mail/common/src/main/java/com/fsck/k9/mail/filter/PeekableInputStream.java b/mail/common/src/main/java/com/fsck/k9/mail/filter/PeekableInputStream.java
deleted file mode 100644
index 4d8836fbb3fde23fa8216ccd8103fb404ddcce67..0000000000000000000000000000000000000000
--- a/mail/common/src/main/java/com/fsck/k9/mail/filter/PeekableInputStream.java
+++ /dev/null
@@ -1,68 +0,0 @@
-package com.fsck.k9.mail.filter;
-
-
-import java.io.FilterInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.Locale;
-
-
-/**
- * A filtering InputStream that allows single byte "peeks" without consuming the byte. The
- * client of this stream can call peek() to see the next available byte in the stream
- * and a subsequent read will still return the peeked byte.
- */
-public class PeekableInputStream extends FilterInputStream {
-    private boolean peeked;
-    private int peekedByte;
-
-
-    public PeekableInputStream(InputStream in) {
-        super(in);
-    }
-
-    @Override
-    public int read() throws IOException {
-        if (!peeked) {
-            return in.read();
-        } else {
-            peeked = false;
-            return peekedByte;
-        }
-    }
-
-    public int peek() throws IOException {
-        if (!peeked) {
-            peekedByte = in.read();
-            peeked = true;
-        }
-        return peekedByte;
-    }
-
-    @Override
-    public int read(byte[] buffer, int offset, int length) throws IOException {
-        if (!peeked) {
-            return in.read(buffer, offset, length);
-        } else {
-            buffer[offset] = (byte) peekedByte;
-            peeked = false;
-            int r = in.read(buffer, offset + 1, length - 1);
-            if (r == -1) {
-                return 1;
-            } else {
-                return r + 1;
-            }
-        }
-    }
-
-    @Override
-    public int read(byte[] buffer) throws IOException {
-        return read(buffer, 0, buffer.length);
-    }
-
-    @Override
-    public String toString() {
-        return String.format(Locale.US, "PeekableInputStream(in=%s, peeked=%b, peekedByte=%d)",
-                in.toString(), peeked, peekedByte);
-    }
-}
diff --git a/mail/common/src/main/java/com/fsck/k9/mail/filter/PeekableInputStream.kt b/mail/common/src/main/java/com/fsck/k9/mail/filter/PeekableInputStream.kt
new file mode 100644
index 0000000000000000000000000000000000000000..4b46bd7f12e7f51dde1be0508dfd0411faeabf65
--- /dev/null
+++ b/mail/common/src/main/java/com/fsck/k9/mail/filter/PeekableInputStream.kt
@@ -0,0 +1,94 @@
+package com.fsck.k9.mail.filter
+
+import java.io.FilterInputStream
+import java.io.IOException
+import java.io.InputStream
+import java.util.Locale
+
+/**
+ * A filtering InputStream that allows single byte "peeks" without consuming the byte.
+ *
+ * The client of this stream can call `peek()` to see the next available byte in the stream and a subsequent read will
+ * still return the peeked byte.
+ */
+class PeekableInputStream(private val inputStream: InputStream) : FilterInputStream(inputStream) {
+    private var peeked = false
+    private var peekedByte = 0
+
+    @Throws(IOException::class)
+    override fun read(): Int {
+        return if (!peeked) {
+            inputStream.read()
+        } else {
+            peeked = false
+            peekedByte
+        }
+    }
+
+    @Throws(IOException::class)
+    fun peek(): Int {
+        if (!peeked) {
+            peekedByte = inputStream.read()
+            peeked = true
+        }
+
+        return peekedByte
+    }
+
+    @Throws(IOException::class)
+    override fun read(buffer: ByteArray, offset: Int, length: Int): Int {
+        return if (!peeked) {
+            inputStream.read(buffer, offset, length)
+        } else {
+            buffer[offset] = peekedByte.toByte()
+            peeked = false
+
+            val numberOfBytesRead = inputStream.read(buffer, offset + 1, length - 1)
+            if (numberOfBytesRead == -1) {
+                1
+            } else {
+                numberOfBytesRead + 1
+            }
+        }
+    }
+
+    @Throws(IOException::class)
+    override fun read(buffer: ByteArray): Int {
+        return read(buffer, 0, buffer.size)
+    }
+
+    @Throws(IOException::class)
+    override fun skip(n: Long): Long {
+        return if (!peeked) {
+            inputStream.skip(n)
+        } else if (n > 0) {
+            peeked = false
+            inputStream.skip(n - 1)
+        } else {
+            0
+        }
+    }
+
+    @Throws(IOException::class)
+    override fun available(): Int {
+        return if (!peeked) {
+            inputStream.available()
+        } else {
+            1 + inputStream.available()
+        }
+    }
+
+    override fun markSupported(): Boolean {
+        // We're not using this mechanism. So it's not worth the effort to add support for mark() and reset().
+        return false
+    }
+
+    override fun toString(): String {
+        return "PeekableInputStream(in=%s, peeked=%b, peekedByte=%d)".format(
+            Locale.ROOT,
+            inputStream.toString(),
+            peeked,
+            peekedByte,
+        )
+    }
+}
diff --git a/mail/common/src/main/java/com/fsck/k9/mail/oauth/AuthStateStorage.kt b/mail/common/src/main/java/com/fsck/k9/mail/oauth/AuthStateStorage.kt
new file mode 100644
index 0000000000000000000000000000000000000000..f740a38771f25fe8e22f19fbccfef4143cc40d11
--- /dev/null
+++ b/mail/common/src/main/java/com/fsck/k9/mail/oauth/AuthStateStorage.kt
@@ -0,0 +1,7 @@
+package com.fsck.k9.mail.oauth
+
+interface AuthStateStorage {
+    fun getAuthorizationState(): String?
+    fun updateAuthorizationState(authorizationState: String?)
+    fun getEmail(): String?
+}
diff --git a/mail/common/src/main/java/com/fsck/k9/mail/oauth/OAuth2TokenProvider.java b/mail/common/src/main/java/com/fsck/k9/mail/oauth/OAuth2TokenProvider.java
index 3c5c732d3ddab24c9aa9c00eb056bd8c4a56b260..e2cab2fd5fa36be5fb67412ffd18e1f27cf1a4aa 100644
--- a/mail/common/src/main/java/com/fsck/k9/mail/oauth/OAuth2TokenProvider.java
+++ b/mail/common/src/main/java/com/fsck/k9/mail/oauth/OAuth2TokenProvider.java
@@ -13,7 +13,7 @@ public interface OAuth2TokenProvider {
     /**
      * Fetch a token. No guarantees are provided for validity.
      */
-    String getToken(String email, long timeoutMillis) throws AuthenticationFailedException;
+    String getToken(long timeoutMillis) throws AuthenticationFailedException;
 
     /**
      * Invalidate the token for this email.
diff --git a/mail/common/src/main/java/com/fsck/k9/mail/oauth/OAuth2TokenProviderFactory.kt b/mail/common/src/main/java/com/fsck/k9/mail/oauth/OAuth2TokenProviderFactory.kt
new file mode 100644
index 0000000000000000000000000000000000000000..b7a8a884413417ecc1d8bc1a9917f998c9524fc2
--- /dev/null
+++ b/mail/common/src/main/java/com/fsck/k9/mail/oauth/OAuth2TokenProviderFactory.kt
@@ -0,0 +1,9 @@
+package com.fsck.k9.mail.oauth
+
+/**
+ * Creates an instance of [OAuth2TokenProvider] that uses a given [AuthStateStorage] to retrieve and store the
+ * (implementation-specific) authorization state.
+ */
+fun interface OAuth2TokenProviderFactory {
+    fun create(authStateStorage: AuthStateStorage): OAuth2TokenProvider
+}
diff --git a/mail/common/src/main/java/com/fsck/k9/mail/server/ServerSettingsValidationResult.kt b/mail/common/src/main/java/com/fsck/k9/mail/server/ServerSettingsValidationResult.kt
new file mode 100644
index 0000000000000000000000000000000000000000..d6baef4721ec00d4d7b251832037702d1eb8deff
--- /dev/null
+++ b/mail/common/src/main/java/com/fsck/k9/mail/server/ServerSettingsValidationResult.kt
@@ -0,0 +1,40 @@
+package com.fsck.k9.mail.server
+
+import com.fsck.k9.mail.ServerSettings
+import java.io.IOException
+import java.security.cert.X509Certificate
+
+/**
+ * Result type for [ServerSettingsValidator].
+ */
+sealed interface ServerSettingsValidationResult {
+    /**
+     * The given [ServerSettings] were successfully used to connect to the server and log in.
+     */
+    object Success : ServerSettingsValidationResult
+
+    /**
+     * A network error occurred while checking the server settings.
+     */
+    data class NetworkError(val exception: IOException) : ServerSettingsValidationResult
+
+    /**
+     * A certificate error occurred while checking the server settings.
+     */
+    data class CertificateError(val certificateChain: List<X509Certificate>) : ServerSettingsValidationResult
+
+    /**
+     * Authentication failed while checking the server settings.
+     */
+    data class AuthenticationError(val serverMessage: String?) : ServerSettingsValidationResult
+
+    /**
+     * The server returned an error while checking the server settings.
+     */
+    data class ServerError(val serverMessage: String?) : ServerSettingsValidationResult
+
+    /**
+     * An unknown error occurred while checking the server settings.
+     */
+    data class UnknownError(val exception: Exception) : ServerSettingsValidationResult
+}
diff --git a/mail/common/src/main/java/com/fsck/k9/mail/server/ServerSettingsValidator.kt b/mail/common/src/main/java/com/fsck/k9/mail/server/ServerSettingsValidator.kt
new file mode 100644
index 0000000000000000000000000000000000000000..fc40167c2e7c986f7968d31e9d58e08418d8f2fe
--- /dev/null
+++ b/mail/common/src/main/java/com/fsck/k9/mail/server/ServerSettingsValidator.kt
@@ -0,0 +1,14 @@
+package com.fsck.k9.mail.server
+
+import com.fsck.k9.mail.ServerSettings
+import com.fsck.k9.mail.oauth.AuthStateStorage
+
+/**
+ * Validate [ServerSettings] by trying to connect to the server and log in.
+ */
+fun interface ServerSettingsValidator {
+    fun checkServerSettings(
+        serverSettings: ServerSettings,
+        authStateStorage: AuthStateStorage?,
+    ): ServerSettingsValidationResult
+}
diff --git a/mail/common/src/main/java/com/fsck/k9/sasl/OAuthBearer.kt b/mail/common/src/main/java/com/fsck/k9/sasl/OAuthBearer.kt
index 531e5b683d486ef0b64ef0635cdef952c07db523..561977fec13d790e2ef140b724f6c8b188d6e085 100644
--- a/mail/common/src/main/java/com/fsck/k9/sasl/OAuthBearer.kt
+++ b/mail/common/src/main/java/com/fsck/k9/sasl/OAuthBearer.kt
@@ -10,6 +10,6 @@ import okio.ByteString.Companion.encodeUtf8
  * See [RFC 7628](https://datatracker.ietf.org/doc/html/rfc7628).
  */
 fun buildOAuthBearerInitialClientResponse(username: String, token: String): String {
-    val saslName = username.replace(",", "=2C").replace("=", "=3D")
+    val saslName = username.replace("=", "=3D").replace(",", "=2C")
     return "n,a=$saslName,\u0001auth=Bearer $token\u0001\u0001".encodeUtf8().base64()
 }
diff --git a/mail/common/src/test/java/com/fsck/k9/mail/MimeTypeTest.kt b/mail/common/src/test/java/com/fsck/k9/mail/MimeTypeTest.kt
index 611592ccfde0be46f4933694d22e00ede4438c47..961ac403e53943cb451d5bd68b5bbc664f024757 100644
--- a/mail/common/src/test/java/com/fsck/k9/mail/MimeTypeTest.kt
+++ b/mail/common/src/test/java/com/fsck/k9/mail/MimeTypeTest.kt
@@ -1,8 +1,8 @@
 package com.fsck.k9.mail
 
+import assertk.assertFailure
 import assertk.assertThat
 import assertk.assertions.isEqualTo
-import assertk.assertions.isFailure
 import assertk.assertions.isInstanceOf
 import assertk.assertions.isNotNull
 import assertk.assertions.isNull
@@ -69,10 +69,9 @@ class MimeTypeTest {
     }
 
     private fun assertInvalidMimeType(input: String) {
-        assertThat {
+        assertFailure {
             input.toMimeType()
-        }.isFailure()
-            .isInstanceOf(IllegalArgumentException::class)
+        }.isInstanceOf<IllegalArgumentException>()
             .message().isNotNull().startsWith("Invalid MIME type: ")
     }
 
diff --git a/mail/common/src/test/java/com/fsck/k9/mail/filter/FixedLengthInputStreamTest.java b/mail/common/src/test/java/com/fsck/k9/mail/filter/FixedLengthInputStreamTest.java
deleted file mode 100644
index b750b5dc349e652f92d58854b5f52f000e111cab..0000000000000000000000000000000000000000
--- a/mail/common/src/test/java/com/fsck/k9/mail/filter/FixedLengthInputStreamTest.java
+++ /dev/null
@@ -1,273 +0,0 @@
-package com.fsck.k9.mail.filter;
-
-
-import java.io.IOException;
-import java.io.InputStream;
-
-import okio.Buffer;
-import okio.ByteString;
-import okio.Okio;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-
-
-public class FixedLengthInputStreamTest {
-    @Test
-    public void readingStream_shouldReturnDataUpToLimit() throws Exception {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Hello world"), 5);
-
-        String readString = readStreamAsUtf8String(fixedLengthInputStream);
-
-        assertEquals("Hello", readString);
-    }
-
-    @Test
-    public void readingStream_shouldNotConsumeMoreThanLimitFromUnderlyingInputStream() throws Exception {
-        InputStream inputStream = inputStream("Hello world");
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream, 5);
-
-        exhaustStream(fixedLengthInputStream);
-
-        assertRemainingInputStreamEquals(" world", inputStream);
-    }
-
-    @Test
-    //TODO: Maybe this should throw. The underlying stream delivering less bytes than expected is most likely an error.
-    public void readingStream_withLimitGreaterThanNumberOfBytesInUnderlyingInputStream() throws Exception {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Hello World"), 100);
-
-        String readString = readStreamAsUtf8String(fixedLengthInputStream);
-
-        assertEquals("Hello World", readString);
-    }
-
-    @Test
-    public void read_withOverSizedByteArray_shouldReturnDataUpToLimit() throws Exception {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Hello World"), 6);
-
-        byte[] data = new byte[100];
-        int numberOfBytesRead = fixedLengthInputStream.read(data);
-
-        assertEquals(6, numberOfBytesRead);
-        assertEquals("Hello ", ByteString.of(data, 0, numberOfBytesRead).utf8());
-    }
-
-    @Test
-    public void read_withOverSizedByteArray_shouldNotConsumeMoreThanLimitFromUnderlyingStream() throws Exception {
-        InputStream inputStream = inputStream("Hello World");
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream, 6);
-
-        //noinspection ResultOfMethodCallIgnored
-        fixedLengthInputStream.read(new byte[100]);
-
-        assertRemainingInputStreamEquals("World", inputStream);
-    }
-
-    @Test
-    public void read_withByteArraySmallerThanLimit_shouldConsumeSizeOfByteArray() throws Exception {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Hello World"), 6);
-
-        byte[] data = new byte[5];
-        int numberOfBytesRead = fixedLengthInputStream.read(data);
-
-        assertEquals(5, numberOfBytesRead);
-        assertEquals("Hello", ByteString.of(data).utf8());
-    }
-
-    @Test
-    public void read_withOverSizedByteArrayInMiddleOfStream_shouldReturnDataUpToLimit() throws Exception {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Hello World"), 6);
-        consumeBytes(fixedLengthInputStream, 5);
-
-        byte[] data = new byte[10];
-        int numberOfBytesRead = fixedLengthInputStream.read(data);
-
-        assertEquals(1, numberOfBytesRead);
-        assertEquals(" ", ByteString.of(data, 0, numberOfBytesRead).utf8());
-    }
-
-    @Test
-    public void read_withOverSizedByteArrayInMiddleOfStream_shouldNotConsumeMoreThanLimitFromUnderlyingStream()
-            throws Exception {
-        InputStream inputStream = inputStream("Hello World");
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream, 6);
-        consumeBytes(fixedLengthInputStream, 5);
-
-        //noinspection ResultOfMethodCallIgnored
-        fixedLengthInputStream.read(new byte[10]);
-
-        assertRemainingInputStreamEquals("World", inputStream);
-    }
-
-    @Test
-    public void read_atStartOfStream() throws Exception {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Word"), 2);
-
-        int readByte = fixedLengthInputStream.read();
-
-        assertEquals('W', (char) readByte);
-    }
-
-    @Test
-    public void read_inMiddleOfStream() throws Exception {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Word"), 2);
-        consumeBytes(fixedLengthInputStream, 1);
-
-        int readByte = fixedLengthInputStream.read();
-
-        assertEquals('o', (char) readByte);
-    }
-
-    @Test
-    public void read_atEndOfStream_shouldReturnMinusOne() throws Exception {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Hello world"), 5);
-        exhaustStream(fixedLengthInputStream);
-
-        int readByte = fixedLengthInputStream.read();
-
-        assertEquals(-1, readByte);
-    }
-
-    @Test
-    public void readArray_atEndOfStream_shouldReturnMinusOne() throws Exception {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Hello world"), 5);
-        exhaustStream(fixedLengthInputStream);
-
-        int numberOfBytesRead = fixedLengthInputStream.read(new byte[2]);
-
-        assertEquals(-1, numberOfBytesRead);
-    }
-
-    @Test
-    public void readArrayWithOffset_atEndOfStream_shouldReturnMinusOne() throws Exception {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Hello world"), 5);
-        exhaustStream(fixedLengthInputStream);
-
-        int numberOfBytesRead = fixedLengthInputStream.read(new byte[2], 0, 2);
-
-        assertEquals(-1, numberOfBytesRead);
-    }
-
-    @Test
-    public void available_atStartOfStream() throws Exception {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Hello World"), 5);
-
-        int available = fixedLengthInputStream.available();
-
-        assertEquals(5, available);
-    }
-
-    @Test
-    public void available_afterPartialRead() throws Exception {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Hello World"), 5);
-        //noinspection ResultOfMethodCallIgnored
-        fixedLengthInputStream.read();
-
-        int available = fixedLengthInputStream.available();
-
-        assertEquals(4, available);
-    }
-
-    @Test
-    public void available_afterPartialReadArray() throws Exception {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Hello World"), 5);
-        consumeBytes(fixedLengthInputStream, 2);
-
-        int available = fixedLengthInputStream.available();
-
-        assertEquals(3, available);
-    }
-
-    @Test
-    public void available_afterStreamHasBeenExhausted() throws Exception {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Hello World"), 5);
-        exhaustStream(fixedLengthInputStream);
-
-        int available = fixedLengthInputStream.available();
-
-        assertEquals(0, available);
-    }
-
-    @Test
-    public void available_afterSkip() throws Exception {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Hello World"), 5);
-        guaranteedSkip(fixedLengthInputStream, 2);
-
-        int available = fixedLengthInputStream.available();
-
-        assertEquals(3, available);
-    }
-
-    @Test
-    public void available_afterSkipRemaining() throws Exception {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Hello World"), 5);
-        fixedLengthInputStream.skipRemaining();
-
-        int available = fixedLengthInputStream.available();
-
-        assertEquals(0, available);
-    }
-
-    @Test
-    public void skip_shouldConsumeBytes() throws IOException {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Hello World"), 5);
-
-        guaranteedSkip(fixedLengthInputStream, 2);
-
-        assertRemainingInputStreamEquals("llo", fixedLengthInputStream);
-    }
-
-    @Test
-    public void skipRemaining_shouldExhaustStream() throws IOException {
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream("Hello World"), 5);
-
-        fixedLengthInputStream.skipRemaining();
-
-        assertInputStreamExhausted(fixedLengthInputStream);
-    }
-
-    @Test
-    public void skipRemaining_shouldNotConsumeMoreThanLimitFromUnderlyingInputStream() throws IOException {
-        InputStream inputStream = inputStream("Hello World");
-        FixedLengthInputStream fixedLengthInputStream = new FixedLengthInputStream(inputStream, 6);
-
-        fixedLengthInputStream.skipRemaining();
-
-        assertRemainingInputStreamEquals("World", inputStream);
-    }
-
-
-    private String readStreamAsUtf8String(InputStream inputStream) throws IOException {
-        return Okio.buffer(Okio.source(inputStream)).readUtf8();
-    }
-
-    private void exhaustStream(InputStream inputStream) throws IOException {
-        Okio.buffer(Okio.source(inputStream)).readAll(Okio.blackhole());
-    }
-
-    private void consumeBytes(InputStream inputStream, int numberOfBytes) throws IOException {
-        int read = inputStream.read(new byte[numberOfBytes]);
-        assertEquals(numberOfBytes, read);
-    }
-
-    private void guaranteedSkip(InputStream inputStream, int numberOfBytesToSkip) throws IOException {
-        int remaining = numberOfBytesToSkip;
-        while (remaining > 0) {
-            remaining -= inputStream.skip(remaining);
-        }
-        assertEquals(0, remaining);
-    }
-
-    private void assertRemainingInputStreamEquals(String expected, InputStream inputStream) throws IOException {
-        assertEquals(expected, readStreamAsUtf8String(inputStream));
-    }
-
-    private void assertInputStreamExhausted(InputStream inputStream) throws IOException {
-        assertEquals(-1, inputStream.read());
-    }
-
-    private InputStream inputStream(String data) {
-        return new Buffer().writeUtf8(data).inputStream();
-    }
-}
diff --git a/mail/common/src/test/java/com/fsck/k9/mail/filter/FixedLengthInputStreamTest.kt b/mail/common/src/test/java/com/fsck/k9/mail/filter/FixedLengthInputStreamTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..8cb17142a249edf94c5bd68b5c2343ec12a5b3dd
--- /dev/null
+++ b/mail/common/src/test/java/com/fsck/k9/mail/filter/FixedLengthInputStreamTest.kt
@@ -0,0 +1,275 @@
+package com.fsck.k9.mail.filter
+
+import assertk.Assert
+import assertk.all
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import java.io.InputStream
+import kotlin.test.Test
+import okio.blackholeSink
+import okio.buffer
+import okio.source
+
+class FixedLengthInputStreamTest {
+    @Test
+    fun `reading stream should return data up to limit`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Hello world", length = 5)
+
+        val result = fixedLengthInputStream.readToString()
+
+        assertThat(result).isEqualTo("Hello")
+    }
+
+    @Test
+    fun `reading stream should not consume more than limit from underlying InputStream`() {
+        val inputStream = "Hello world".byteInputStream()
+        val fixedLengthInputStream = FixedLengthInputStream(inputStream, 5)
+
+        fixedLengthInputStream.exhaust()
+
+        assertThat(inputStream).readToString().isEqualTo(" world")
+    }
+
+    // TODO: Maybe this should throw. The underlying stream delivering less bytes than expected is most likely an error.
+    @Test
+    fun `reading stream with limit greater than number of bytes in underlying InputStream`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Hello world", length = 100)
+
+        val result = fixedLengthInputStream.readToString()
+
+        assertThat(result).isEqualTo("Hello world")
+    }
+
+    @Test
+    fun `read() with oversized ByteArray should return data up to limit`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Hello World", length = 6)
+        val data = ByteArray(100)
+
+        val result = fixedLengthInputStream.read(data)
+
+        assertThat(result).isEqualTo(6)
+        assertThat(data).all {
+            slice(0 until 6).asString().isEqualTo("Hello ")
+            slice(6 until 100).isEqualTo(ByteArray(100 - 6))
+        }
+    }
+
+    @Test
+    fun `read() with oversized ByteArray should not consume more than limit from underlying InputStream`() {
+        val inputStream = "Hello World".byteInputStream()
+        val fixedLengthInputStream = FixedLengthInputStream(inputStream, 6)
+
+        fixedLengthInputStream.read(ByteArray(100))
+
+        assertThat(inputStream).readToString().isEqualTo("World")
+    }
+
+    @Test
+    fun `read() with ByteArray smaller than limit should consume size of ByteArray`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Hello World", length = 6)
+        val data = ByteArray(5)
+
+        val result = fixedLengthInputStream.read(data)
+
+        assertThat(result).isEqualTo(5)
+        assertThat(data).asString().isEqualTo("Hello")
+    }
+
+    @Test
+    fun `read() with oversized ByteArray in middle of stream should return data up to limit`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Hello World", length = 6)
+        fixedLengthInputStream.consumeBytes(5)
+        val data = ByteArray(10)
+
+        val result = fixedLengthInputStream.read(data)
+
+        assertThat(result).isEqualTo(1)
+        assertThat(data).all {
+            slice(0 until 1).asString().isEqualTo(" ")
+            slice(1 until 10).isEqualTo(ByteArray(10 - 1))
+        }
+    }
+
+    @Test
+    fun `read() with oversized ByteArray in middle of stream should not read more than limit from underlying stream`() {
+        val inputStream = "Hello World".byteInputStream()
+        val fixedLengthInputStream = FixedLengthInputStream(inputStream, 6)
+        fixedLengthInputStream.consumeBytes(5)
+
+        fixedLengthInputStream.read(ByteArray(10))
+
+        assertThat(inputStream).readToString().isEqualTo("World")
+    }
+
+    @Test
+    fun `read() at start of stream`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Word", length = 2)
+
+        val result = fixedLengthInputStream.read()
+
+        assertThat(result).isEqualTo('W'.code)
+    }
+
+    @Test
+    fun `read() in middle of stream`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Word", length = 2)
+        fixedLengthInputStream.consumeBytes(1)
+
+        val result = fixedLengthInputStream.read()
+
+        assertThat(result).isEqualTo('o'.code)
+    }
+
+    @Test
+    fun `read() at end of stream should return -1`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Hello world", length = 5)
+        fixedLengthInputStream.exhaust()
+
+        val result = fixedLengthInputStream.read()
+
+        assertThat(result).isEqualTo(-1)
+    }
+
+    @Test
+    fun `read(ByteArray) at end of stream should return -1`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Hello world", length = 5)
+        fixedLengthInputStream.exhaust()
+
+        val result = fixedLengthInputStream.read(ByteArray(2))
+
+        assertThat(result).isEqualTo(-1)
+    }
+
+    @Test
+    fun `read(ByteArray) with offset at end of stream should return -1`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Hello world", length = 5)
+        fixedLengthInputStream.exhaust()
+
+        val result = fixedLengthInputStream.read(ByteArray(2), 0, 2)
+
+        assertThat(result).isEqualTo(-1)
+    }
+
+    @Test
+    fun `available() at start of stream`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Hello world", length = 5)
+
+        val result = fixedLengthInputStream.available()
+
+        assertThat(result).isEqualTo(5)
+    }
+
+    @Test
+    fun `available() after partial read`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Hello world", length = 5)
+        fixedLengthInputStream.read()
+
+        val result = fixedLengthInputStream.available()
+
+        assertThat(result).isEqualTo(4)
+    }
+
+    @Test
+    fun `available() after partial multi-byte read`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Hello world", length = 5)
+        fixedLengthInputStream.consumeBytes(2)
+
+        val result = fixedLengthInputStream.available()
+
+        assertThat(result).isEqualTo(3)
+    }
+
+    @Test
+    fun `available() after stream has been exhausted`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Hello world", length = 5)
+        fixedLengthInputStream.exhaust()
+
+        val result = fixedLengthInputStream.available()
+
+        assertThat(result).isEqualTo(0)
+    }
+
+    @Test
+    fun `available() after skip()`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Hello world", length = 5)
+        fixedLengthInputStream.guaranteedSkip(2)
+
+        val result = fixedLengthInputStream.available()
+
+        assertThat(result).isEqualTo(3)
+    }
+
+    @Test
+    fun `available() after skip remaining`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Hello world", length = 5)
+        fixedLengthInputStream.skipRemaining()
+
+        val result = fixedLengthInputStream.available()
+
+        assertThat(result).isEqualTo(0)
+    }
+
+    @Test
+    fun `skip() should consume bytes`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Hello world", length = 5)
+
+        fixedLengthInputStream.guaranteedSkip(2)
+
+        assertThat(fixedLengthInputStream).readToString().isEqualTo("llo")
+    }
+
+    @Test
+    fun `skipRemaining() should exhaust stream`() {
+        val fixedLengthInputStream = createFixedLengthInputStream(data = "Hello world", length = 5)
+
+        fixedLengthInputStream.skipRemaining()
+
+        assertThat(fixedLengthInputStream).isExhausted()
+    }
+
+    @Test
+    fun `skipRemaining() should not consume more than limit from underlying InputStream`() {
+        val inputStream = "Hello World".byteInputStream()
+        val fixedLengthInputStream = FixedLengthInputStream(inputStream, 6)
+
+        fixedLengthInputStream.skipRemaining()
+
+        assertThat(inputStream).readToString().isEqualTo("World")
+    }
+
+    private fun createFixedLengthInputStream(data: String, length: Int): FixedLengthInputStream {
+        return FixedLengthInputStream(data.byteInputStream(), length)
+    }
+
+    private fun InputStream.guaranteedSkip(numberOfBytesToSkip: Int) {
+        var remaining = numberOfBytesToSkip.toLong()
+        while (remaining > 0) {
+            remaining -= skip(remaining)
+        }
+
+        assertThat(remaining).isEqualTo(0L)
+    }
+
+    private fun InputStream.readToString(): String = source().buffer().readUtf8()
+
+    private fun InputStream.exhaust() {
+        source().buffer().readAll(blackholeSink())
+    }
+
+    private fun InputStream.consumeBytes(numberOfBytes: Int) {
+        val numberOfBytesRead = read(ByteArray(numberOfBytes))
+
+        assertThat(numberOfBytesRead).isEqualTo(numberOfBytes)
+    }
+
+    private fun Assert<InputStream>.isExhausted() = given { actual ->
+        assertThat(actual.read()).isEqualTo(-1)
+        assertThat(actual.available()).isEqualTo(0)
+    }
+
+    private fun Assert<InputStream>.readToString() = transform { it.readToString() }
+
+    private fun Assert<ByteArray>.slice(range: IntRange) = transform { it.sliceArray(range) }
+
+    private fun Assert<ByteArray>.asString() = transform { String(it) }
+}
diff --git a/mail/common/src/test/java/com/fsck/k9/mail/filter/PeekableInputStreamTest.kt b/mail/common/src/test/java/com/fsck/k9/mail/filter/PeekableInputStreamTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..74745f76f45f80e825d07207e02209453baf8b8d
--- /dev/null
+++ b/mail/common/src/test/java/com/fsck/k9/mail/filter/PeekableInputStreamTest.kt
@@ -0,0 +1,195 @@
+package com.fsck.k9.mail.filter
+
+import assertk.assertThat
+import assertk.assertions.contains
+import assertk.assertions.containsExactly
+import assertk.assertions.isEqualTo
+import assertk.assertions.isFalse
+import assertk.assertions.isTrue
+import java.io.InputStream
+import kotlin.test.Test
+
+class PeekableInputStreamTest {
+    @Test
+    fun `read() should read bytes`() {
+        val inputBytes = "abc".toByteArray()
+        val peekableInputStream = PeekableInputStream(inputBytes.inputStream())
+
+        assertThat(peekableInputStream.read()).isEqualTo('a'.code)
+        assertThat(peekableInputStream.read()).isEqualTo('b'.code)
+        assertThat(peekableInputStream.read()).isEqualTo('c'.code)
+        assertThat(peekableInputStream.read()).isEqualTo(-1)
+    }
+
+    @Test
+    fun `read(ByteArray) should write bytes to array`() {
+        val inputBytes = byteArrayOf(1, 2, 3)
+        val peekableInputStream = PeekableInputStream(inputBytes.inputStream())
+        val data = ByteArray(4)
+
+        val numberOfBytesRead = peekableInputStream.read(data)
+
+        assertThat(numberOfBytesRead).isEqualTo(3)
+        assertThat(data).containsExactly(1, 2, 3, 0)
+    }
+
+    @Test
+    fun `read(ByteArray, Int, Int) should write bytes to array`() {
+        val inputBytes = byteArrayOf(1, 2, 3)
+        val peekableInputStream = PeekableInputStream(inputBytes.inputStream())
+        val data = ByteArray(5)
+
+        val numberOfBytesRead = peekableInputStream.read(data, 1, 3)
+
+        assertThat(numberOfBytesRead).isEqualTo(3)
+        assertThat(data).containsExactly(0, 1, 2, 3, 0)
+    }
+
+    @Test
+    fun `peek() before read()`() {
+        val inputBytes = "ab".toByteArray()
+        val peekableInputStream = PeekableInputStream(inputBytes.inputStream())
+
+        assertThat(peekableInputStream.peek()).isEqualTo('a'.code)
+        assertThat(peekableInputStream.read()).isEqualTo('a'.code)
+        assertThat(peekableInputStream.peek()).isEqualTo('b'.code)
+        assertThat(peekableInputStream.read()).isEqualTo('b'.code)
+        assertThat(peekableInputStream.peek()).isEqualTo(-1)
+        assertThat(peekableInputStream.read()).isEqualTo(-1)
+    }
+
+    @Test
+    fun `peek() before read(ByteArray)`() {
+        val inputBytes = byteArrayOf(1, 2, 3)
+        val peekableInputStream = PeekableInputStream(inputBytes.inputStream())
+        val data = ByteArray(4)
+
+        val peeked = peekableInputStream.peek()
+
+        assertThat(peeked).isEqualTo(1)
+
+        val numberOfBytesRead = peekableInputStream.read(data)
+
+        assertThat(numberOfBytesRead).isEqualTo(3)
+        assertThat(data).containsExactly(1, 2, 3, 0)
+    }
+
+    @Test
+    fun `peek() on last byte before read(ByteArray)`() {
+        val inputBytes = byteArrayOf(1)
+        val peekableInputStream = PeekableInputStream(inputBytes.inputStream())
+        val data = ByteArray(1)
+
+        val peeked = peekableInputStream.peek()
+
+        assertThat(peeked).isEqualTo(1)
+
+        val numberOfBytesRead = peekableInputStream.read(data)
+
+        assertThat(numberOfBytesRead).isEqualTo(1)
+        assertThat(data).containsExactly(1)
+    }
+
+    @Test
+    fun `peek() before read(ByteArray, Int, Int)`() {
+        val inputBytes = byteArrayOf(1, 2, 3)
+        val peekableInputStream = PeekableInputStream(inputBytes.inputStream())
+        val data = ByteArray(5)
+
+        val peeked = peekableInputStream.peek()
+
+        assertThat(peeked).isEqualTo(1)
+
+        val numberOfBytesRead = peekableInputStream.read(data, 1, 3)
+
+        assertThat(numberOfBytesRead).isEqualTo(3)
+        assertThat(data).containsExactly(0, 1, 2, 3, 0)
+    }
+
+    @Test
+    fun `close() should close wrapped InputStream`() {
+        val wrappedInputStream = object : InputStream() {
+            var isClosed = false
+
+            override fun read(): Int {
+                throw UnsupportedOperationException("not implemented")
+            }
+
+            override fun close() {
+                isClosed = true
+            }
+        }
+        val peekableInputStream = PeekableInputStream(wrappedInputStream)
+
+        peekableInputStream.close()
+
+        assertThat(wrappedInputStream.isClosed).isTrue()
+    }
+
+    @Test
+    fun `read() after peek() should read same byte`() {
+        val wrappedInputStream = "Test".byteInputStream()
+        val peekableInputStream = PeekableInputStream(wrappedInputStream)
+
+        val peeked = peekableInputStream.peek()
+
+        assertThat(peeked).isEqualTo('T'.code)
+
+        val read = peekableInputStream.read()
+
+        assertThat(read).isEqualTo('T'.code)
+    }
+
+    @Test
+    fun `skip() should skip correct amount of bytes`() {
+        val wrappedInputStream = "Test".byteInputStream()
+        val peekableInputStream = PeekableInputStream(wrappedInputStream)
+
+        peekableInputStream.skip(2)
+
+        assertThat(peekableInputStream.readToString()).isEqualTo("st")
+    }
+
+    @Test
+    fun `skip() after peek() should skip correct amount of bytes`() {
+        val wrappedInputStream = "Test".byteInputStream()
+        val peekableInputStream = PeekableInputStream(wrappedInputStream)
+
+        peekableInputStream.peek()
+        peekableInputStream.skip(2)
+
+        assertThat(peekableInputStream.readToString()).isEqualTo("st")
+    }
+
+    @Test
+    fun `available() should return number of available bytes`() {
+        val wrappedInputStream = "Test".byteInputStream()
+        val peekableInputStream = PeekableInputStream(wrappedInputStream)
+
+        val available = peekableInputStream.available()
+
+        assertThat(available).isEqualTo(4)
+    }
+
+    @Test
+    fun `available() after peek() should return number of available bytes`() {
+        val wrappedInputStream = "Test".byteInputStream()
+        val peekableInputStream = PeekableInputStream(wrappedInputStream)
+
+        peekableInputStream.peek()
+        val available = peekableInputStream.available()
+
+        assertThat(available).isEqualTo(4)
+    }
+
+    @Test
+    fun `markSupported() should return false`() {
+        val peekableInputStream = PeekableInputStream("abc".byteInputStream())
+
+        val result = peekableInputStream.markSupported()
+
+        assertThat(result).isFalse()
+    }
+
+    private fun InputStream.readToString() = readBytes().decodeToString()
+}
diff --git a/mail/common/src/test/java/com/fsck/k9/mail/internet/AddressHeaderBuilderTest.kt b/mail/common/src/test/java/com/fsck/k9/mail/internet/AddressHeaderBuilderTest.kt
index 156458f46889a93808fc743bc6d87e0a12916f4f..f710ba6d9f458a954c9c6a0bc42dccc3860d4e8d 100644
--- a/mail/common/src/test/java/com/fsck/k9/mail/internet/AddressHeaderBuilderTest.kt
+++ b/mail/common/src/test/java/com/fsck/k9/mail/internet/AddressHeaderBuilderTest.kt
@@ -1,8 +1,12 @@
 package com.fsck.k9.mail.internet
 
+import assertk.assertFailure
+import assertk.assertThat
+import assertk.assertions.hasMessage
+import assertk.assertions.isEqualTo
+import assertk.assertions.isInstanceOf
 import com.fsck.k9.mail.Address
 import com.fsck.k9.mail.crlf
-import org.junit.Assert.assertEquals
 import org.junit.Test
 
 class AddressHeaderBuilderTest {
@@ -13,7 +17,7 @@ class AddressHeaderBuilderTest {
 
         val headerValue = AddressHeaderBuilder.createHeaderValue(addresses)
 
-        assertEquals("test@domain.example", headerValue)
+        assertThat(headerValue).isEqualTo("test@domain.example")
     }
 
     @Test
@@ -25,7 +29,7 @@ class AddressHeaderBuilderTest {
 
         val headerValue = AddressHeaderBuilder.createHeaderValue(addresses)
 
-        assertEquals("one@domain.example, two@domain.example", headerValue)
+        assertThat(headerValue).isEqualTo("one@domain.example, two@domain.example")
     }
 
     @Test
@@ -40,19 +44,21 @@ class AddressHeaderBuilderTest {
 
         val headerValue = AddressHeaderBuilder.createHeaderValue(addresses)
 
-        assertEquals(
+        assertThat(headerValue).isEqualTo(
             """
             |Person One <one@domain.example>,
             | "Person \"Long Email Address\" Two" <two+because.i.can@this.is.quite.some.domain.example>,
             | Person Three <three@domain.example>, Person Four <four@domain.example>,
             | Person Five <five@domain.example>
             """.trimMargin().crlf(),
-            headerValue,
         )
     }
 
-    @Test(expected = IllegalArgumentException::class)
+    @Test
     fun createHeaderValue_withoutAddresses_shouldThrow() {
-        AddressHeaderBuilder.createHeaderValue(emptyArray())
+        assertFailure {
+            AddressHeaderBuilder.createHeaderValue(emptyArray())
+        }.isInstanceOf<IllegalArgumentException>()
+            .hasMessage("addresses must not be empty")
     }
 }
diff --git a/mail/common/src/test/java/com/fsck/k9/mail/internet/EncoderUtilTest.kt b/mail/common/src/test/java/com/fsck/k9/mail/internet/EncoderUtilTest.kt
index 22015a333b0f8bbbf9d01aaf55d077d440328617..acf887dbf98c4ee6b6f3aa5405686af8ee41e74e 100644
--- a/mail/common/src/test/java/com/fsck/k9/mail/internet/EncoderUtilTest.kt
+++ b/mail/common/src/test/java/com/fsck/k9/mail/internet/EncoderUtilTest.kt
@@ -1,33 +1,36 @@
 package com.fsck.k9.mail.internet
 
-import org.junit.Assert.assertEquals
+import assertk.assertThat
+import assertk.assertions.isEqualTo
 import org.junit.Test
 
 class EncoderUtilTest {
     @Test
     fun singleNonAsciiCharacter() {
-        assertInputEncodesToExpected("123456789Ä", "=?UTF-8?Q?123456789=C3=84?=")
+        val result = EncoderUtil.encodeEncodedWord("123456789Ä")
+
+        assertThat(result).isEqualTo("=?UTF-8?Q?123456789=C3=84?=")
     }
 
     @Test
     fun onlyNonAsciiCharacters() {
-        assertInputEncodesToExpected("ÄÖÜÄÖÜÄÖÜÄ", "=?UTF-8?B?w4TDlsOcw4TDlsOcw4TDlsOcw4Q=?=")
+        val result = EncoderUtil.encodeEncodedWord("ÄÖÜÄÖÜÄÖÜÄ")
+
+        assertThat(result).isEqualTo("=?UTF-8?B?w4TDlsOcw4TDlsOcw4TDlsOcw4Q=?=")
     }
 
     @Test
     fun nonAsciiCharactersThatNeedToBeEncodedAsMultipleEncodedWords() {
-        assertInputEncodesToExpected(
+        val result = EncoderUtil.encodeEncodedWord(
             "Re: \uD83D\uDC15\uD83D\uDC36\uD83D\uDC29\uD83D\uDC08\uD83D\uDC31\uD83D\uDC00\uD83D\uDC01\uD83D\uDC2D" +
                 "\uD83D\uDC39\uD83D\uDC22\uD83D\uDC07\uD83D\uDC30\uD83D\uDC13\uD83D\uDC14\uD83D\uDC23\uD83D\uDC24" +
                 "\uD83D\uDC25\uD83D\uDC26\uD83D\uDC0F\uD83D\uDC11\uD83D\uDC10",
+        )
+
+        assertThat(result).isEqualTo(
             "=?UTF-8?B?UmU6IPCfkJXwn5C28J+QqfCfkIjwn5Cx8J+QgPCfkIHwn5Ct8J+QuQ==?= " +
                 "=?UTF-8?B?8J+QovCfkIfwn5Cw8J+Qk/CfkJTwn5Cj?= " +
                 "=?UTF-8?B?8J+QpPCfkKXwn5Cm8J+Qj/CfkJHwn5CQ?=",
         )
     }
-
-    private fun assertInputEncodesToExpected(input: String, expected: String) {
-        val encodedText = EncoderUtil.encodeEncodedWord(input)
-        assertEquals(expected, encodedText)
-    }
 }
diff --git a/mail/common/src/test/java/com/fsck/k9/mail/internet/MessageIdGeneratorTest.kt b/mail/common/src/test/java/com/fsck/k9/mail/internet/MessageIdGeneratorTest.kt
index 64668e46e77d291a41cc805230bee0ee5d91255b..4a4350e99c28e344cb43fa3dbb52befcd091e610 100644
--- a/mail/common/src/test/java/com/fsck/k9/mail/internet/MessageIdGeneratorTest.kt
+++ b/mail/common/src/test/java/com/fsck/k9/mail/internet/MessageIdGeneratorTest.kt
@@ -1,7 +1,8 @@
 package com.fsck.k9.mail.internet
 
+import assertk.assertThat
+import assertk.assertions.isEqualTo
 import com.fsck.k9.mail.Address
-import org.junit.Assert.assertEquals
 import org.junit.Test
 
 class MessageIdGeneratorTest {
@@ -20,7 +21,7 @@ class MessageIdGeneratorTest {
 
         val result = messageIdGenerator.generateMessageId(message)
 
-        assertEquals("<00000000-0000-4000-0000-000000000000@example.org>", result)
+        assertThat(result).isEqualTo("<00000000-0000-4000-0000-000000000000@example.org>")
     }
 
     @Test
@@ -31,7 +32,7 @@ class MessageIdGeneratorTest {
 
         val result = messageIdGenerator.generateMessageId(message)
 
-        assertEquals("<00000000-0000-4000-0000-000000000000@example.com>", result)
+        assertThat(result).isEqualTo("<00000000-0000-4000-0000-000000000000@example.com>")
     }
 
     @Test
@@ -40,6 +41,6 @@ class MessageIdGeneratorTest {
 
         val result = messageIdGenerator.generateMessageId(message)
 
-        assertEquals("<00000000-0000-4000-0000-000000000000@fallback.k9mail.app>", result)
+        assertThat(result).isEqualTo("<00000000-0000-4000-0000-000000000000@fallback.k9mail.app>")
     }
 }
diff --git a/mail/common/src/test/java/com/fsck/k9/mail/internet/MimeHeaderCheckerTest.kt b/mail/common/src/test/java/com/fsck/k9/mail/internet/MimeHeaderCheckerTest.kt
index 189a90938085643b39a4b16dbd8f33b215d97c00..9c5ed4543bef2298f49e66499ced1e02419b0be7 100644
--- a/mail/common/src/test/java/com/fsck/k9/mail/internet/MimeHeaderCheckerTest.kt
+++ b/mail/common/src/test/java/com/fsck/k9/mail/internet/MimeHeaderCheckerTest.kt
@@ -1,6 +1,7 @@
 package com.fsck.k9.mail.internet
 
-import org.junit.Assert.fail
+import assertk.assertFailure
+import assertk.assertions.isInstanceOf
 import org.junit.Test
 
 class MimeHeaderCheckerTest {
@@ -196,15 +197,15 @@ class MimeHeaderCheckerTest {
 
     private fun assertValidHeader(header: String) {
         val (name, value) = header.split(": ", limit = 2)
+
         MimeHeaderChecker.checkHeader(name, value)
     }
 
     private fun assertInvalidHeader(header: String) {
         val (name, value) = header.split(": ", limit = 2)
-        try {
+
+        assertFailure {
             MimeHeaderChecker.checkHeader(name, value)
-            fail("Expected exception")
-        } catch (expected: MimeHeaderParserException) {
-        }
+        }.isInstanceOf<MimeHeaderParserException>()
     }
 }
diff --git a/mail/protocols/imap/src/main/java/com/fsck/k9/mail/store/imap/ImapServerSettingsValidator.kt b/mail/protocols/imap/src/main/java/com/fsck/k9/mail/store/imap/ImapServerSettingsValidator.kt
new file mode 100644
index 0000000000000000000000000000000000000000..71be1ff197a48cb1cb11586078c9b77e8b39161c
--- /dev/null
+++ b/mail/protocols/imap/src/main/java/com/fsck/k9/mail/store/imap/ImapServerSettingsValidator.kt
@@ -0,0 +1,63 @@
+package com.fsck.k9.mail.store.imap
+
+import com.fsck.k9.mail.AuthenticationFailedException
+import com.fsck.k9.mail.CertificateValidationException
+import com.fsck.k9.mail.MessagingException
+import com.fsck.k9.mail.ServerSettings
+import com.fsck.k9.mail.oauth.AuthStateStorage
+import com.fsck.k9.mail.oauth.OAuth2TokenProvider
+import com.fsck.k9.mail.oauth.OAuth2TokenProviderFactory
+import com.fsck.k9.mail.server.ServerSettingsValidationResult
+import com.fsck.k9.mail.server.ServerSettingsValidator
+import com.fsck.k9.mail.ssl.TrustedSocketFactory
+import java.io.IOException
+
+class ImapServerSettingsValidator(
+    private val trustedSocketFactory: TrustedSocketFactory,
+    private val oAuth2TokenProviderFactory: OAuth2TokenProviderFactory?,
+    private val clientIdAppName: String,
+) : ServerSettingsValidator {
+
+    @Suppress("TooGenericExceptionCaught")
+    override fun checkServerSettings(
+        serverSettings: ServerSettings,
+        authStateStorage: AuthStateStorage?,
+    ): ServerSettingsValidationResult {
+        val config = object : ImapStoreConfig {
+            override val logLabel = "check"
+            override fun isSubscribedFoldersOnly() = false
+            override fun clientIdAppName() = clientIdAppName
+        }
+        val oAuth2TokenProvider = createOAuth2TokenProviderOrNull(authStateStorage)
+        val store = RealImapStore(serverSettings, config, trustedSocketFactory, oAuth2TokenProvider)
+
+        return try {
+            store.checkSettings()
+
+            ServerSettingsValidationResult.Success
+        } catch (e: AuthenticationFailedException) {
+            ServerSettingsValidationResult.AuthenticationError(e.messageFromServer)
+        } catch (e: CertificateValidationException) {
+            ServerSettingsValidationResult.CertificateError(e.certChain.toList())
+        } catch (e: NegativeImapResponseException) {
+            ServerSettingsValidationResult.ServerError(e.responseText)
+        } catch (e: MessagingException) {
+            val cause = e.cause
+            if (cause is IOException) {
+                ServerSettingsValidationResult.NetworkError(cause)
+            } else {
+                ServerSettingsValidationResult.UnknownError(e)
+            }
+        } catch (e: IOException) {
+            ServerSettingsValidationResult.NetworkError(e)
+        } catch (e: Exception) {
+            ServerSettingsValidationResult.UnknownError(e)
+        }
+    }
+
+    private fun createOAuth2TokenProviderOrNull(authStateStorage: AuthStateStorage?): OAuth2TokenProvider? {
+        return authStateStorage?.let {
+            oAuth2TokenProviderFactory?.create(it)
+        }
+    }
+}
diff --git a/mail/protocols/imap/src/main/java/com/fsck/k9/mail/store/imap/ImapStoreConfig.kt b/mail/protocols/imap/src/main/java/com/fsck/k9/mail/store/imap/ImapStoreConfig.kt
index 295ba4536d860d76b23bcea72206cf4e6c016e20..e844d869766660c9b5cf72b2d8511aaf1bebf822 100644
--- a/mail/protocols/imap/src/main/java/com/fsck/k9/mail/store/imap/ImapStoreConfig.kt
+++ b/mail/protocols/imap/src/main/java/com/fsck/k9/mail/store/imap/ImapStoreConfig.kt
@@ -3,6 +3,5 @@ package com.fsck.k9.mail.store.imap
 interface ImapStoreConfig {
     val logLabel: String
     fun isSubscribedFoldersOnly(): Boolean
-    fun useCompression(): Boolean
-    fun clientIdAppName(): String?
+    fun clientIdAppName(): String
 }
diff --git a/mail/protocols/imap/src/main/java/com/fsck/k9/mail/store/imap/ImapStoreSettings.kt b/mail/protocols/imap/src/main/java/com/fsck/k9/mail/store/imap/ImapStoreSettings.kt
index db7a0da20ee7d3c7dfe64b9fab0b987945fdf7e4..9d6b8fabacafb9d0077c3988f97b80e8c83ef27d 100644
--- a/mail/protocols/imap/src/main/java/com/fsck/k9/mail/store/imap/ImapStoreSettings.kt
+++ b/mail/protocols/imap/src/main/java/com/fsck/k9/mail/store/imap/ImapStoreSettings.kt
@@ -8,6 +8,8 @@ import com.fsck.k9.mail.ServerSettings
 object ImapStoreSettings {
     private const val AUTODETECT_NAMESPACE_KEY = "autoDetectNamespace"
     private const val PATH_PREFIX_KEY = "pathPrefix"
+    private const val SEND_CLIENT_ID = "sendClientId"
+    private const val USE_COMPRESSION = "useCompression"
 
     @JvmStatic
     val ServerSettings.autoDetectNamespace: Boolean
@@ -17,6 +19,15 @@ object ImapStoreSettings {
     val ServerSettings.pathPrefix: String?
         get() = extra[PATH_PREFIX_KEY]
 
+    @JvmStatic
+    val ServerSettings.isUseCompression: Boolean
+        get() = extra[USE_COMPRESSION]?.toBoolean() ?: true
+
+    @JvmStatic
+    val ServerSettings.isSendClientId: Boolean
+        get() = extra[SEND_CLIENT_ID]?.toBoolean() ?: true
+
+    // Note: These extras are currently held in the instance referenced by Account.incomingServerSettings
     @JvmStatic
     fun createExtra(autoDetectNamespace: Boolean, pathPrefix: String?): Map<String, String?> {
         return mapOf(
@@ -24,4 +35,19 @@ object ImapStoreSettings {
             PATH_PREFIX_KEY to pathPrefix,
         )
     }
+
+    // Note: These extras are required when creating an ImapStore instance.
+    fun createExtra(
+        autoDetectNamespace: Boolean,
+        pathPrefix: String?,
+        useCompression: Boolean,
+        sendClientId: Boolean,
+    ): Map<String, String?> {
+        return mapOf(
+            AUTODETECT_NAMESPACE_KEY to autoDetectNamespace.toString(),
+            PATH_PREFIX_KEY to pathPrefix,
+            USE_COMPRESSION to useCompression.toString(),
+            SEND_CLIENT_ID to sendClientId.toString(),
+        )
+    }
 }
diff --git a/mail/protocols/imap/src/main/java/com/fsck/k9/mail/store/imap/NegativeImapResponseException.java b/mail/protocols/imap/src/main/java/com/fsck/k9/mail/store/imap/NegativeImapResponseException.java
deleted file mode 100644
index 6a1c44f0c4585101f0152e9f61323b93df38e190..0000000000000000000000000000000000000000
--- a/mail/protocols/imap/src/main/java/com/fsck/k9/mail/store/imap/NegativeImapResponseException.java
+++ /dev/null
@@ -1,43 +0,0 @@
-package com.fsck.k9.mail.store.imap;
-
-import java.util.List;
-
-import com.fsck.k9.mail.MessagingException;
-
-import static com.fsck.k9.mail.store.imap.ImapResponseParser.equalsIgnoreCase;
-
-
-class NegativeImapResponseException extends MessagingException {
-    private static final long serialVersionUID = 3725007182205882394L;
-
-    private final List<ImapResponse> responses;
-    private String alertText;
-
-    public NegativeImapResponseException(String message, List<ImapResponse> responses) {
-        super(message, true);
-        this.responses = responses;
-    }
-
-    public String getAlertText() {
-        if (alertText == null) {
-            ImapResponse lastResponse = getLastResponse();
-            alertText = AlertResponse.getAlertText(lastResponse);
-        }
-        
-        return alertText;
-    }
-
-    public boolean wasByeResponseReceived() {
-        for (ImapResponse response : responses) {
-            if (response.getTag() == null && response.size() >= 1 && equalsIgnoreCase(response.get(0), Responses.BYE)) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    public ImapResponse getLastResponse() {
-        return responses.get(responses.size() - 1);
-    }
-}
diff --git a/mail/protocols/imap/src/main/java/com/fsck/k9/mail/store/imap/NegativeImapResponseException.kt b/mail/protocols/imap/src/main/java/com/fsck/k9/mail/store/imap/NegativeImapResponseException.kt
new file mode 100644
index 0000000000000000000000000000000000000000..7db696e2145965536d3f636484f91ec43f22e1af
--- /dev/null
+++ b/mail/protocols/imap/src/main/java/com/fsck/k9/mail/store/imap/NegativeImapResponseException.kt
@@ -0,0 +1,27 @@
+package com.fsck.k9.mail.store.imap
+
+import com.fsck.k9.mail.MessagingException
+
+internal class NegativeImapResponseException(
+    message: String?,
+    private val responses: List<ImapResponse>,
+) : MessagingException(message, true) {
+
+    init {
+        require(responses.isNotEmpty()) { "List of responses must not be empty" }
+    }
+
+    val lastResponse: ImapResponse
+        get() = responses.last()
+
+    val responseText: String? by lazy { ResponseTextExtractor.getResponseText(lastResponse) }
+
+    val alertText: String? by lazy { AlertResponse.getAlertText(lastResponse) }
+
+    fun wasByeResponseReceived(): Boolean {
+        return responses.any { it.isByeResponse }
+    }
+
+    private val ImapResponse.isByeResponse: Boolean
+        get() = !isTagged && isNotEmpty() && ImapResponseParser.equalsIgnoreCase(first(), Responses.BYE)
+}
diff --git a/mail/protocols/imap/src/main/java/com/fsck/k9/mail/store/imap/RealImapConnection.kt b/mail/protocols/imap/src/main/java/com/fsck/k9/mail/store/imap/RealImapConnection.kt
index 2ed4acb3a6afee8fb2ba050e8d628fcf5be9a1a8..15c788802b73a7bfe01a0feb33dc111c683ff3cc 100644
--- a/mail/protocols/imap/src/main/java/com/fsck/k9/mail/store/imap/RealImapConnection.kt
+++ b/mail/protocols/imap/src/main/java/com/fsck/k9/mail/store/imap/RealImapConnection.kt
@@ -363,7 +363,7 @@ internal class RealImapConnection(
         return AuthenticationFailedException(
             message = "Authentication failed",
             throwable = e,
-            messageFromServer = ResponseTextExtractor.getResponseText(e.lastResponse),
+            messageFromServer = e.responseText,
         )
     }
 
@@ -393,7 +393,7 @@ internal class RealImapConnection(
         val oauthTokenProvider = checkNotNull(oauthTokenProvider)
         val responseParser = checkNotNull(responseParser)
 
-        val token = oauthTokenProvider.getToken(settings.username, OAuth2TokenProvider.OAUTH2_TIMEOUT.toLong())
+        val token = oauthTokenProvider.getToken(OAuth2TokenProvider.OAUTH2_TIMEOUT.toLong())
 
         val authString = method.buildInitialClientResponse(settings.username, token)
         val tag = sendSaslIrCommand(method.command, authString, true)
@@ -547,7 +547,7 @@ internal class RealImapConnection(
             AuthenticationFailedException(
                 message = "Authentication failed",
                 throwable = negativeResponseException,
-                messageFromServer = ResponseTextExtractor.getResponseText(lastResponse),
+                messageFromServer = negativeResponseException.responseText,
             )
         } else {
             close()
diff --git a/mail/protocols/imap/src/main/java/com/fsck/k9/mail/store/imap/RealImapFolder.kt b/mail/protocols/imap/src/main/java/com/fsck/k9/mail/store/imap/RealImapFolder.kt
index 6746d8905206ddacfa88828395b1244bfdd6c340..26ff4103d486c0be1dbb4fea30c3159d96abd208 100644
--- a/mail/protocols/imap/src/main/java/com/fsck/k9/mail/store/imap/RealImapFolder.kt
+++ b/mail/protocols/imap/src/main/java/com/fsck/k9/mail/store/imap/RealImapFolder.kt
@@ -543,7 +543,7 @@ internal class RealImapFolder(
             fetchFields.add("RFC822.SIZE")
             fetchFields.add(
                 "BODY.PEEK[HEADER.FIELDS (date subject from content-type to cc bcc " +
-                    "reply-to message-id references in-reply-to list-unsubscribe sender " +
+                    "reply-to message-id references in-reply-to list-post list-unsubscribe sender " +
                     K9MailLib.IDENTITY_HEADER + " " + K9MailLib.CHAT_HEADER + ")]",
             )
         }
diff --git a/mail/protocols/imap/src/main/java/com/fsck/k9/mail/store/imap/RealImapStore.kt b/mail/protocols/imap/src/main/java/com/fsck/k9/mail/store/imap/RealImapStore.kt
index 54870e662657a52c36f1ddef17cae28c5a69325c..d3adc14412db601613fd1a58dc4a4a0d6e560be4 100644
--- a/mail/protocols/imap/src/main/java/com/fsck/k9/mail/store/imap/RealImapStore.kt
+++ b/mail/protocols/imap/src/main/java/com/fsck/k9/mail/store/imap/RealImapStore.kt
@@ -11,6 +11,8 @@ import com.fsck.k9.mail.ServerSettings
 import com.fsck.k9.mail.oauth.OAuth2TokenProvider
 import com.fsck.k9.mail.ssl.TrustedSocketFactory
 import com.fsck.k9.mail.store.imap.ImapStoreSettings.autoDetectNamespace
+import com.fsck.k9.mail.store.imap.ImapStoreSettings.isSendClientId
+import com.fsck.k9.mail.store.imap.ImapStoreSettings.isUseCompression
 import com.fsck.k9.mail.store.imap.ImapStoreSettings.pathPrefix
 import java.io.IOException
 import java.util.Deque
@@ -37,6 +39,8 @@ internal open class RealImapStore(
     private var connectionGeneration = 1
 
     init {
+        require(serverSettings.type == "imap") { "Expected IMAP ServerSettings" }
+
         val autoDetectNamespace = serverSettings.autoDetectNamespace
         val pathPrefixSetting = serverSettings.pathPrefix
 
@@ -296,11 +300,9 @@ internal open class RealImapStore(
         override val password: String? = serverSettings.password
         override val clientCertificateAlias: String? = serverSettings.clientCertificateAlias
 
-        override val useCompression: Boolean
-            get() = this@RealImapStore.config.useCompression()
+        override val useCompression: Boolean = serverSettings.isUseCompression
 
-        override val clientIdAppName: String?
-            get() = this@RealImapStore.config.clientIdAppName()
+        override val clientIdAppName: String? = config.clientIdAppName().takeIf { serverSettings.isSendClientId }
 
         override var pathPrefix: String?
             get() = this@RealImapStore.pathPrefix
diff --git a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/ImapResponseParserTest.kt b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/ImapResponseParserTest.kt
index a79e9d8783bd8a67770368abe6bacd2d053a0673..9b18748219df4055230985e0c9416133060f451f 100644
--- a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/ImapResponseParserTest.kt
+++ b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/ImapResponseParserTest.kt
@@ -1,6 +1,7 @@
 package com.fsck.k9.mail.store.imap
 
 import assertk.all
+import assertk.assertFailure
 import assertk.assertThat
 import assertk.assertions.cause
 import assertk.assertions.containsExactly
@@ -8,10 +9,10 @@ import assertk.assertions.hasMessage
 import assertk.assertions.hasSize
 import assertk.assertions.index
 import assertk.assertions.isEqualTo
-import assertk.assertions.isFailure
 import assertk.assertions.isInstanceOf
 import assertk.assertions.isNotNull
 import assertk.assertions.isNull
+import assertk.assertions.isSameAs
 import assertk.assertions.isTrue
 import assertk.assertions.prop
 import com.fsck.k9.mail.filter.FixedLengthInputStream
@@ -51,7 +52,7 @@ class ImapResponseParserTest {
 
         assertThat(response).hasSize(2)
         assertThat(response).index(0).isEqualTo("OK")
-        assertThat(response).index(1).isInstanceOf(ImapList::class).containsExactly("UIDVALIDITY", "3857529045")
+        assertThat(response).index(1).isInstanceOf<ImapList>().containsExactly("UIDVALIDITY", "3857529045")
         assertThatAllInputWasConsumed()
     }
 
@@ -63,7 +64,7 @@ class ImapResponseParserTest {
 
         assertThat(response).hasSize(3)
         assertThat(response).index(0).isEqualTo("OK")
-        assertThat(response).index(1).isInstanceOf(ImapList::class).containsExactly("token1", "token2")
+        assertThat(response).index(1).isInstanceOf<ImapList>().containsExactly("token1", "token2")
         assertThat(response).index(2).isEqualTo("{x} test [...]")
         assertThatAllInputWasConsumed()
     }
@@ -148,10 +149,9 @@ class ImapResponseParserTest {
             "TAG ERROR COMMAND errored",
         )
 
-        assertThat {
+        assertFailure {
             parser.readStatusResponse("TAG", null, null, null)
-        }.isFailure()
-            .isInstanceOf(NegativeImapResponseException::class)
+        }.isInstanceOf<NegativeImapResponseException>()
     }
 
     @Test
@@ -165,9 +165,9 @@ class ImapResponseParserTest {
 
         assertThat(response).hasSize(3)
         assertThat(response).index(0).isEqualTo("OK")
-        assertThat(response).index(1).isInstanceOf(ImapList::class).all {
+        assertThat(response).index(1).isInstanceOf<ImapList>().all {
             index(0).isEqualTo("PERMANENTFLAGS")
-            index(1).isInstanceOf(ImapList::class).containsExactly(
+            index(1).isInstanceOf<ImapList>().containsExactly(
                 """\Answered""",
                 """\Flagged""",
                 """\Deleted""",
@@ -199,10 +199,9 @@ class ImapResponseParserTest {
     fun `readResponse() should throw if stream ends before end of line is found`() {
         val parser = createParserWithData("* OK Some text ")
 
-        assertThat {
+        assertFailure {
             parser.readResponse()
-        }.isFailure()
-            .isInstanceOf(IOException::class)
+        }.isInstanceOf<IOException>()
     }
 
     @Test
@@ -240,10 +239,9 @@ class ImapResponseParserTest {
     fun `readResponse() with literal containing negative size`() {
         val parser = createParserWithResponses("* {-1}")
 
-        assertThat {
+        assertFailure {
             parser.readResponse()
-        }.isFailure()
-            .isInstanceOf(ImapResponseParserException::class)
+        }.isInstanceOf<ImapResponseParserException>()
             .hasMessage("Invalid value for size of literal string")
     }
 
@@ -251,10 +249,9 @@ class ImapResponseParserTest {
     fun `readResponse() with literal size exceeding Int`() {
         val parser = createParserWithResponses("* {2147483648}")
 
-        assertThat {
+        assertFailure {
             parser.readResponse()
-        }.isFailure()
-            .isInstanceOf(ImapResponseParserException::class)
+        }.isInstanceOf<ImapResponseParserException>()
             .hasMessage("Invalid value for size of literal string")
     }
 
@@ -262,10 +259,9 @@ class ImapResponseParserTest {
     fun `readResponse() with invalid characters for literal size`() {
         val parser = createParserWithResponses("* {invalid}")
 
-        assertThat {
+        assertFailure {
             parser.readResponse()
-        }.isFailure()
-            .isInstanceOf(ImapResponseParserException::class)
+        }.isInstanceOf<ImapResponseParserException>()
             .hasMessage("Invalid value for size of literal string")
     }
 
@@ -273,10 +269,9 @@ class ImapResponseParserTest {
     fun `readResponse() should throw when end of stream is reached while reading literal`() {
         val parser = createParserWithData("* {4}\r\nabc")
 
-        assertThat {
+        assertFailure {
             parser.readResponse()
-        }.isFailure()
-            .isInstanceOf(IOException::class)
+        }.isInstanceOf<IOException>()
     }
 
     @Test
@@ -307,10 +302,9 @@ class ImapResponseParserTest {
         val parser = createParserWithResponses("* {4}\r\ntest")
         val callback = TestImapResponseCallback.readBytesAndReturn(2, null)
 
-        assertThat {
+        assertFailure {
             parser.readResponse(callback)
-        }.isFailure()
-            .isInstanceOf(AssertionError::class)
+        }.isInstanceOf<AssertionError>()
             .hasMessage("Callback consumed some data but returned no result")
     }
 
@@ -319,13 +313,12 @@ class ImapResponseParserTest {
         val parser = createParserWithResponses("* {4}\r\ntest")
         val callback = TestImapResponseCallback.readBytesAndThrow(2)
 
-        assertThat {
+        assertFailure {
             parser.readResponse(callback)
-        }.isFailure()
-            .isInstanceOf(ImapResponseParserException::class)
+        }.isInstanceOf<ImapResponseParserException>()
             .all {
                 hasMessage("readResponse(): Exception in callback method")
-                cause().isNotNull().isInstanceOf(ImapResponseParserTestException::class)
+                cause().isNotNull().isInstanceOf<ImapResponseParserTestException>()
             }
         assertThatAllInputWasConsumed()
     }
@@ -335,13 +328,12 @@ class ImapResponseParserTest {
         val parser = createParserWithResponses("* {3}\r\none {3}\r\ntwo")
         val callback = TestImapResponseCallback.readBytesAndThrow(3)
 
-        assertThat {
+        assertFailure {
             parser.readResponse(callback)
-        }.isFailure()
-            .isInstanceOf(ImapResponseParserException::class)
+        }.isInstanceOf<ImapResponseParserException>()
             .all {
                 hasMessage("readResponse(): Exception in callback method")
-                cause().isNotNull().isInstanceOf(ImapResponseParserTestException::class)
+                cause().isNotNull().isInstanceOf<ImapResponseParserTestException>()
                     .prop(ImapResponseParserTestException::instanceNumber).isEqualTo(0)
             }
         assertThatAllInputWasConsumed()
@@ -363,10 +355,9 @@ class ImapResponseParserTest {
         val parser = createParserWithResponses("* {4}\r\ntest")
         val callback = TestImapResponseCallback.readBytesAndThrow(0)
 
-        assertThat {
+        assertFailure {
             parser.readResponse(callback)
-        }.isFailure()
-            .isInstanceOf(ImapResponseParserException::class)
+        }.isInstanceOf<ImapResponseParserException>()
             .hasMessage("readResponse(): Exception in callback method")
         assertThatAllInputWasConsumed()
     }
@@ -377,10 +368,9 @@ class ImapResponseParserTest {
         val exception = IOException()
         val callback = ImapResponseCallback { _, _ -> throw exception }
 
-        assertThat {
+        assertFailure {
             parser.readResponse(callback)
-        }.isFailure()
-            .isEqualTo(exception)
+        }.isSameAs(exception)
     }
 
     @Test
@@ -407,30 +397,27 @@ class ImapResponseParserTest {
     fun `readResponse() should throw when end of stream is reached before end of quoted string`() {
         val parser = createParserWithResponses("* \"abc")
 
-        assertThat {
+        assertFailure {
             parser.readResponse()
-        }.isFailure()
-            .isInstanceOf(IOException::class)
+        }.isInstanceOf<IOException>()
     }
 
     @Test
     fun `readResponse() should throw if end of stream is reached before end of atom`() {
         val parser = createParserWithData("* abc")
 
-        assertThat {
+        assertFailure {
             parser.readResponse()
-        }.isFailure()
-            .isInstanceOf(IOException::class)
+        }.isInstanceOf<IOException>()
     }
 
     @Test
     fun `readResponse() should throw if untagged response indicator is not followed by a space`() {
         val parser = createParserWithResponses("*")
 
-        assertThat {
+        assertFailure {
             parser.readResponse()
-        }.isFailure()
-            .isInstanceOf(IOException::class)
+        }.isInstanceOf<IOException>()
     }
 
     @Test
@@ -441,7 +428,7 @@ class ImapResponseParserTest {
 
         assertThat(response).hasSize(4)
         assertThat(response).index(0).isEqualTo("LIST")
-        assertThat(response).index(1).isInstanceOf(ImapList::class).containsExactly("""\HasNoChildren""")
+        assertThat(response).index(1).isInstanceOf<ImapList>().containsExactly("""\HasNoChildren""")
         assertThat(response).index(2).isEqualTo(".")
         assertThat(response).index(3).isEqualTo("[FolderName]")
         assertThatAllInputWasConsumed()
@@ -451,10 +438,9 @@ class ImapResponseParserTest {
     fun `readResponse() with LIST response containing folder name with parentheses should throw`() {
         val parser = createParserWithResponses("""* LIST (\NoInferiors) "/" Root/Folder/Subfolder()""")
 
-        assertThat {
+        assertFailure {
             parser.readResponse()
-        }.isFailure()
-            .isInstanceOf(IOException::class)
+        }.isInstanceOf<IOException>()
     }
 
     @Test
@@ -479,7 +465,7 @@ class ImapResponseParserTest {
 
         assertThat(response).hasSize(4)
         assertThat(response).index(0).isEqualTo("LIST")
-        assertThat(response).index(1).isInstanceOf(ImapList::class).containsExactly("""\NoInferiors""")
+        assertThat(response).index(1).isInstanceOf<ImapList>().containsExactly("""\NoInferiors""")
         assertThat(response).index(2).isNull()
         assertThat(response).index(3).isEqualTo("INBOX")
         assertThatAllInputWasConsumed()
@@ -489,10 +475,9 @@ class ImapResponseParserTest {
     fun `readResponse() with tagged response missing completion code should throw`() {
         val parser = createParserWithResponses("tag ")
 
-        assertThat {
+        assertFailure {
             parser.readResponse()
-        }.isFailure()
-            .isInstanceOf(ImapResponseParserException::class)
+        }.isInstanceOf<ImapResponseParserException>()
             .hasMessage("Unexpected non-string token")
     }
 
@@ -500,10 +485,9 @@ class ImapResponseParserTest {
     fun `readResponse() with list as first token should throw`() {
         val parser = createParserWithResponses("* [1 2] 3")
 
-        assertThat {
+        assertFailure {
             parser.readResponse()
-        }.isFailure()
-            .isInstanceOf(ImapResponseParserException::class)
+        }.isInstanceOf<ImapResponseParserException>()
             .hasMessage("Unexpected non-string token")
     }
 
@@ -524,7 +508,7 @@ class ImapResponseParserTest {
         assertThat(response).hasSize(3)
         assertThat(response).index(0).isEqualTo("1")
         assertThat(response).index(1).isEqualTo("FETCH")
-        assertThat(response).index(2).isInstanceOf(ImapList::class).all {
+        assertThat(response).index(2).isInstanceOf<ImapList>().all {
             hasSize(11)
             index(0).isEqualTo("UID")
             index(1).isEqualTo("23")
@@ -533,14 +517,14 @@ class ImapResponseParserTest {
             index(4).isEqualTo("RFC822.SIZE")
             index(5).isEqualTo("3456")
             index(6).isEqualTo("BODY")
-            index(7).isInstanceOf(ImapList::class).all {
+            index(7).isInstanceOf<ImapList>().all {
                 hasSize(2)
                 index(0).isEqualTo("HEADER.FIELDS")
-                index(1).isInstanceOf(ImapList::class).containsExactly("date", "subject", "from")
+                index(1).isInstanceOf<ImapList>().containsExactly("date", "subject", "from")
             }
             index(8).isEqualTo("<headers>")
             index(9).isEqualTo("FLAGS")
-            index(10).isInstanceOf(ImapList::class).containsExactly("""\Seen""")
+            index(10).isInstanceOf<ImapList>().containsExactly("""\Seen""")
         }
         assertThatAllInputWasConsumed()
     }
@@ -549,10 +533,9 @@ class ImapResponseParserTest {
     fun `readStatusResponse() with NO response should throw`() {
         val parser = createParserWithResponses("1 NO")
 
-        assertThat {
+        assertFailure {
             parser.readStatusResponse("1", "COMMAND", "[logId]", null)
-        }.isFailure()
-            .isInstanceOf(NegativeImapResponseException::class)
+        }.isInstanceOf<NegativeImapResponseException>()
             .hasMessage("Command: COMMAND; response: #1# [NO]")
     }
 
@@ -560,11 +543,10 @@ class ImapResponseParserTest {
     fun `readStatusResponse() with NO response and alert text should throw with alert text`() {
         val parser = createParserWithResponses("1 NO [ALERT] Access denied\r\n")
 
-        assertThat {
+        assertFailure {
             parser.readStatusResponse("1", "COMMAND", "[logId]", null)
-        }.isFailure()
-            .isInstanceOf(NegativeImapResponseException::class)
-            .prop(NegativeImapResponseException::getAlertText).isEqualTo("Access denied")
+        }.isInstanceOf<NegativeImapResponseException>()
+            .prop(NegativeImapResponseException::alertText).isEqualTo("Access denied")
     }
 
     private fun createParserWithResponses(vararg responses: String): ImapResponseParser {
diff --git a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/ImapServerSettingsValidatorTest.kt b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/ImapServerSettingsValidatorTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..a04b417c14b0d7031c5763e3b21a018a9482fadc
--- /dev/null
+++ b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/ImapServerSettingsValidatorTest.kt
@@ -0,0 +1,285 @@
+package com.fsck.k9.mail.store.imap
+
+import assertk.assertFailure
+import assertk.assertThat
+import assertk.assertions.hasSize
+import assertk.assertions.isEqualTo
+import assertk.assertions.isInstanceOf
+import assertk.assertions.prop
+import com.fsck.k9.mail.AuthType
+import com.fsck.k9.mail.ConnectionSecurity
+import com.fsck.k9.mail.ServerSettings
+import com.fsck.k9.mail.helpers.FakeTrustManager
+import com.fsck.k9.mail.helpers.SimpleTrustedSocketFactory
+import com.fsck.k9.mail.oauth.AuthStateStorage
+import com.fsck.k9.mail.oauth.OAuth2TokenProvider
+import com.fsck.k9.mail.server.ServerSettingsValidationResult
+import com.fsck.k9.mail.store.imap.mockserver.MockImapServer
+import java.net.UnknownHostException
+import kotlin.test.Test
+
+private const val USERNAME = "user"
+private const val PASSWORD = "password"
+private const val AUTHORIZATION_STATE = "auth state"
+private const val AUTHORIZATION_TOKEN = "auth-token"
+private val CLIENT_CERTIFICATE_ALIAS: String? = null
+private const val CLIENT_ID = "clientId"
+
+class ImapServerSettingsValidatorTest {
+    private val fakeTrustManager = FakeTrustManager()
+    private val trustedSocketFactory = SimpleTrustedSocketFactory(fakeTrustManager)
+    private val serverSettingsValidator = ImapServerSettingsValidator(
+        trustedSocketFactory = trustedSocketFactory,
+        oAuth2TokenProviderFactory = null,
+        clientIdAppName = CLIENT_ID,
+    )
+
+    @Test
+    fun `valid server settings with password should return Success`() {
+        val server = startServer {
+            output("* OK IMAP4rev1 server ready")
+            expect("1 CAPABILITY")
+            output("* CAPABILITY IMAP4rev1 AUTH=PLAIN")
+            output("1 OK CAPABILITY Completed")
+            expect("2 AUTHENTICATE PLAIN")
+            output("+")
+            expect("AHVzZXIAcGFzc3dvcmQ=")
+            output("2 OK [CAPABILITY IMAP4rev1 AUTH=PLAIN NAMESPACE ID] LOGIN completed")
+            expect("3 ID (\"name\" \"$CLIENT_ID\")")
+            output("* ID NIL")
+            output("3 OK ID completed")
+            expect("4 NAMESPACE")
+            output("* NAMESPACE ((\"\" \"/\")) NIL NIL")
+            output("4 OK command completed")
+        }
+        val serverSettings = ServerSettings(
+            type = "imap",
+            host = server.host,
+            port = server.port,
+            connectionSecurity = ConnectionSecurity.NONE,
+            authenticationType = AuthType.PLAIN,
+            username = USERNAME,
+            password = PASSWORD,
+            clientCertificateAlias = CLIENT_CERTIFICATE_ALIAS,
+            extra = ImapStoreSettings.createExtra(
+                autoDetectNamespace = true,
+                pathPrefix = null,
+                useCompression = false,
+                sendClientId = true,
+            ),
+        )
+
+        val result = serverSettingsValidator.checkServerSettings(serverSettings, authStateStorage = null)
+
+        assertThat(result).isInstanceOf<ServerSettingsValidationResult.Success>()
+        server.verifyConnectionClosed()
+        server.verifyInteractionCompleted()
+    }
+
+    @Test
+    fun `valid server settings with OAuth should return Success`() {
+        val serverSettingsValidator = ImapServerSettingsValidator(
+            trustedSocketFactory = trustedSocketFactory,
+            oAuth2TokenProviderFactory = { authStateStorage ->
+                assertThat(authStateStorage.getAuthorizationState()).isEqualTo(AUTHORIZATION_STATE)
+                FakeOAuth2TokenProvider()
+            },
+            clientIdAppName = CLIENT_ID,
+        )
+        val server = startServer {
+            output("* OK IMAP4rev1 server ready")
+            expect("1 CAPABILITY")
+            output("* CAPABILITY IMAP4rev1 SASL-IR AUTH=PLAIN AUTH=OAUTHBEARER")
+            output("1 OK CAPABILITY Completed")
+            expect("2 AUTHENTICATE OAUTHBEARER bixhPXVzZXIsAWF1dGg9QmVhcmVyIGF1dGgtdG9rZW4BAQ==")
+            output("2 OK [CAPABILITY IMAP4rev1 SASL-IR AUTH=PLAIN AUTH=OAUTHBEARER NAMESPACE ID] LOGIN completed")
+            expect("3 ID (\"name\" \"$CLIENT_ID\")")
+            output("* ID NIL")
+            output("3 OK ID completed")
+            expect("4 NAMESPACE")
+            output("* NAMESPACE ((\"\" \"/\")) NIL NIL")
+            output("4 OK command completed")
+        }
+        val serverSettings = ServerSettings(
+            type = "imap",
+            host = server.host,
+            port = server.port,
+            connectionSecurity = ConnectionSecurity.NONE,
+            authenticationType = AuthType.XOAUTH2,
+            username = USERNAME,
+            password = PASSWORD,
+            clientCertificateAlias = CLIENT_CERTIFICATE_ALIAS,
+            extra = ImapStoreSettings.createExtra(
+                autoDetectNamespace = true,
+                pathPrefix = null,
+                useCompression = false,
+                sendClientId = true,
+            ),
+        )
+        val authStateStorage = FakeAuthStateStorage(authorizationState = AUTHORIZATION_STATE)
+
+        val result = serverSettingsValidator.checkServerSettings(serverSettings, authStateStorage)
+
+        assertThat(result).isInstanceOf<ServerSettingsValidationResult.Success>()
+        server.verifyConnectionClosed()
+        server.verifyInteractionCompleted()
+    }
+
+    @Test
+    fun `authentication error should return AuthenticationError`() {
+        val server = startServer {
+            output("* OK IMAP4rev1 server ready")
+            expect("1 CAPABILITY")
+            output("* CAPABILITY IMAP4rev1")
+            output("1 OK CAPABILITY Completed")
+            expect("2 LOGIN \"user\" \"password\"")
+            output("2 NO [AUTHENTICATIONFAILED] Authentication failed")
+            closeConnection()
+        }
+        val serverSettings = ServerSettings(
+            type = "imap",
+            host = server.host,
+            port = server.port,
+            connectionSecurity = ConnectionSecurity.NONE,
+            authenticationType = AuthType.PLAIN,
+            username = USERNAME,
+            password = PASSWORD,
+            clientCertificateAlias = CLIENT_CERTIFICATE_ALIAS,
+        )
+
+        val result = serverSettingsValidator.checkServerSettings(serverSettings, authStateStorage = null)
+
+        assertThat(result).isInstanceOf<ServerSettingsValidationResult.AuthenticationError>()
+            .prop(ServerSettingsValidationResult.AuthenticationError::serverMessage).isEqualTo("Authentication failed")
+        server.verifyConnectionClosed()
+        server.verifyInteractionCompleted()
+    }
+
+    @Test
+    fun `error response should return ServerError`() {
+        val server = startServer {
+            output("* OK IMAP4rev1 server ready")
+            expect("1 CAPABILITY")
+            output("1 BAD Something went wrong")
+            closeConnection()
+        }
+        val serverSettings = ServerSettings(
+            type = "imap",
+            host = server.host,
+            port = server.port,
+            connectionSecurity = ConnectionSecurity.NONE,
+            authenticationType = AuthType.PLAIN,
+            username = USERNAME,
+            password = PASSWORD,
+            clientCertificateAlias = CLIENT_CERTIFICATE_ALIAS,
+        )
+
+        val result = serverSettingsValidator.checkServerSettings(serverSettings, authStateStorage = null)
+
+        assertThat(result).isInstanceOf<ServerSettingsValidationResult.ServerError>()
+        server.verifyConnectionClosed()
+        server.verifyInteractionCompleted()
+    }
+
+    @Test
+    fun `certificate error when trying to connect should return CertificateError`() {
+        fakeTrustManager.shouldThrowException = true
+        val server = startServer {
+            output("* OK IMAP4rev1 server ready")
+            expect("1 CAPABILITY")
+            output("* CAPABILITY IMAP4rev1 AUTH=PLAIN STARTTLS")
+            output("1 OK CAPABILITY Completed")
+            expect("2 STARTTLS")
+            output("2 OK Begin TLS negotiation now")
+            startTls()
+        }
+        val serverSettings = ServerSettings(
+            type = "imap",
+            host = server.host,
+            port = server.port,
+            connectionSecurity = ConnectionSecurity.STARTTLS_REQUIRED,
+            authenticationType = AuthType.PLAIN,
+            username = USERNAME,
+            password = PASSWORD,
+            clientCertificateAlias = CLIENT_CERTIFICATE_ALIAS,
+        )
+
+        val result = serverSettingsValidator.checkServerSettings(serverSettings, authStateStorage = null)
+
+        assertThat(result).isInstanceOf<ServerSettingsValidationResult.CertificateError>()
+            .prop(ServerSettingsValidationResult.CertificateError::certificateChain).hasSize(1)
+        server.verifyConnectionClosed()
+        server.verifyInteractionCompleted()
+    }
+
+    @Test
+    fun `non-existent hostname should return NetworkError`() {
+        val serverSettings = ServerSettings(
+            type = "imap",
+            host = "domain.invalid",
+            port = 587,
+            connectionSecurity = ConnectionSecurity.NONE,
+            authenticationType = AuthType.PLAIN,
+            username = USERNAME,
+            password = PASSWORD,
+            clientCertificateAlias = CLIENT_CERTIFICATE_ALIAS,
+        )
+
+        val result = serverSettingsValidator.checkServerSettings(serverSettings, authStateStorage = null)
+
+        assertThat(result).isInstanceOf<ServerSettingsValidationResult.NetworkError>()
+            .prop(ServerSettingsValidationResult.NetworkError::exception)
+            .isInstanceOf<UnknownHostException>()
+    }
+
+    @Test
+    fun `ServerSettings with wrong type should throw`() {
+        val serverSettings = ServerSettings(
+            type = "wrong",
+            host = "domain.invalid",
+            port = 587,
+            connectionSecurity = ConnectionSecurity.NONE,
+            authenticationType = AuthType.PLAIN,
+            username = USERNAME,
+            password = PASSWORD,
+            clientCertificateAlias = CLIENT_CERTIFICATE_ALIAS,
+        )
+
+        assertFailure {
+            serverSettingsValidator.checkServerSettings(serverSettings, authStateStorage = null)
+        }.isInstanceOf<IllegalArgumentException>()
+    }
+
+    private fun startServer(block: MockImapServer.() -> Unit): MockImapServer {
+        return MockImapServer().apply {
+            block()
+            start()
+        }
+    }
+}
+
+class FakeOAuth2TokenProvider : OAuth2TokenProvider {
+    override fun getToken(timeoutMillis: Long): String {
+        return AUTHORIZATION_TOKEN
+    }
+
+    override fun invalidateToken() {
+        throw UnsupportedOperationException("not implemented")
+    }
+}
+
+class FakeAuthStateStorage(
+    private var authorizationState: String? = null,
+) : AuthStateStorage {
+    override fun getAuthorizationState(): String? {
+        return authorizationState
+    }
+
+    override fun updateAuthorizationState(authorizationState: String?) {
+        this.authorizationState = authorizationState
+    }
+
+    override fun getEmail(): String? {
+        return null
+    }
+}
diff --git a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/NegativeImapResponseExceptionTest.kt b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/NegativeImapResponseExceptionTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..be9f8c49139f80bb3a8d05f6000bf11349683755
--- /dev/null
+++ b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/NegativeImapResponseExceptionTest.kt
@@ -0,0 +1,78 @@
+package com.fsck.k9.mail.store.imap
+
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.isFalse
+import assertk.assertions.isNull
+import assertk.assertions.isTrue
+import com.fsck.k9.mail.store.imap.ImapResponseHelper.createImapResponseList
+import kotlin.test.Test
+
+class NegativeImapResponseExceptionTest {
+    @Test
+    fun `responseText property should contain response text of last response`() {
+        val exception = NegativeImapResponseException(
+            message = "Test",
+            responses = createImapResponseList("x NO [AUTHENTICATIONFAILED] Authentication error #23"),
+        )
+
+        assertThat(exception.responseText).isEqualTo("Authentication error #23")
+    }
+
+    @Test
+    fun `responseText property should be null when last response does not contain response text`() {
+        val exception = NegativeImapResponseException(
+            message = "Test",
+            responses = createImapResponseList("x NO"),
+        )
+
+        assertThat(exception.responseText).isNull()
+    }
+
+    @Test
+    fun `alertText property should contain alert text of last response`() {
+        val exception = NegativeImapResponseException(
+            message = "Test",
+            responses = createImapResponseList("x NO [ALERT] Service is shutting down"),
+        )
+
+        assertThat(exception.alertText).isEqualTo("Service is shutting down")
+    }
+
+    @Test
+    fun `alertText property should be null when last response does not contain alert text`() {
+        val exception = NegativeImapResponseException(
+            message = "Test",
+            responses = createImapResponseList("x NO Not allowed"),
+        )
+
+        assertThat(exception.alertText).isNull()
+    }
+
+    @Test
+    fun `wasByeResponseReceived() should return true when BYE response was received`() {
+        val exception = NegativeImapResponseException(
+            message = "Test",
+            responses = createImapResponseList(
+                "* EXISTS 1",
+                "* BYE",
+                "x OK",
+            ),
+        )
+
+        assertThat(exception.wasByeResponseReceived()).isTrue()
+    }
+
+    @Test
+    fun `wasByeResponseReceived() should return false when no BYE response was received`() {
+        val exception = NegativeImapResponseException(
+            message = "Test",
+            responses = createImapResponseList(
+                "* EXISTS 1",
+                "x OK",
+            ),
+        )
+
+        assertThat(exception.wasByeResponseReceived()).isFalse()
+    }
+}
diff --git a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapConnectionTest.kt b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapConnectionTest.kt
index 620452e26f64c3436c9224ecf8d3eccb3f583707..9112da2648e72bd8b19fe409ab52c066d7983529 100644
--- a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapConnectionTest.kt
+++ b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapConnectionTest.kt
@@ -1,12 +1,12 @@
 package com.fsck.k9.mail.store.imap
 
+import assertk.assertFailure
 import assertk.assertThat
 import assertk.assertions.contains
 import assertk.assertions.containsExactly
 import assertk.assertions.hasMessage
 import assertk.assertions.hasSize
 import assertk.assertions.isEqualTo
-import assertk.assertions.isFailure
 import assertk.assertions.isFalse
 import assertk.assertions.isInstanceOf
 import assertk.assertions.isNotNull
@@ -128,10 +128,9 @@ class RealImapConnectionTest {
         imapConnection.open()
         imapConnection.close()
 
-        assertThat {
+        assertFailure {
             imapConnection.open()
-        }.isFailure()
-            .isInstanceOf(IllegalStateException::class)
+        }.isInstanceOf<IllegalStateException>()
             .hasMessage("open() called after close(). Check wrapped exception to see where close() was called.")
     }
 
@@ -142,10 +141,9 @@ class RealImapConnectionTest {
         }
         val imapConnection = startServerAndCreateImapConnection(server, authType = AuthType.PLAIN)
 
-        assertThat {
+        assertFailure {
             imapConnection.open()
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("Server doesn't support unencrypted passwords using AUTH=PLAIN and LOGIN is disabled.")
 
         server.verifyConnectionClosed()
@@ -185,10 +183,9 @@ class RealImapConnectionTest {
         }
         val imapConnection = startServerAndCreateImapConnection(server, authType = AuthType.PLAIN)
 
-        assertThat {
+        assertFailure {
             imapConnection.open()
-        }.isFailure()
-            .isInstanceOf(AuthenticationFailedException::class)
+        }.isInstanceOf<AuthenticationFailedException>()
             .prop(AuthenticationFailedException::messageFromServer)
             .isEqualTo("Go away")
 
@@ -208,10 +205,9 @@ class RealImapConnectionTest {
         }
         val imapConnection = startServerAndCreateImapConnection(server, authType = AuthType.PLAIN)
 
-        assertThat {
+        assertFailure {
             imapConnection.open()
-        }.isFailure()
-            .isInstanceOf(NegativeImapResponseException::class)
+        }.isInstanceOf<NegativeImapResponseException>()
             .message().isNotNull().contains("Maximum number of connections from user+IP exceeded")
 
         assertThat(imapConnection.isConnected).isFalse()
@@ -232,10 +228,9 @@ class RealImapConnectionTest {
         }
         val imapConnection = startServerAndCreateImapConnection(server, authType = AuthType.PLAIN)
 
-        assertThat {
+        assertFailure {
             imapConnection.open()
-        }.isFailure()
-            .isInstanceOf(AuthenticationFailedException::class)
+        }.isInstanceOf<AuthenticationFailedException>()
             .prop(AuthenticationFailedException::messageFromServer)
             .isEqualTo("Login Failure")
 
@@ -288,10 +283,9 @@ class RealImapConnectionTest {
         }
         val imapConnection = startServerAndCreateImapConnection(server, authType = AuthType.CRAM_MD5)
 
-        assertThat {
+        assertFailure {
             imapConnection.open()
-        }.isFailure()
-            .isInstanceOf(AuthenticationFailedException::class)
+        }.isInstanceOf<AuthenticationFailedException>()
             .prop(AuthenticationFailedException::messageFromServer)
             .isEqualTo("Who are you?")
 
@@ -306,10 +300,9 @@ class RealImapConnectionTest {
         }
         val imapConnection = startServerAndCreateImapConnection(server, authType = AuthType.CRAM_MD5)
 
-        assertThat {
+        assertFailure {
             imapConnection.open()
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("Server doesn't support encrypted passwords using CRAM-MD5.")
 
         server.verifyConnectionClosed()
@@ -393,10 +386,9 @@ class RealImapConnectionTest {
         }
         val imapConnection = startServerAndCreateImapConnection(server, authType = AuthType.XOAUTH2)
 
-        assertThat {
+        assertFailure {
             imapConnection.open()
-        }.isFailure()
-            .isInstanceOf(AuthenticationFailedException::class)
+        }.isInstanceOf<AuthenticationFailedException>()
             .prop(AuthenticationFailedException::messageFromServer)
             .isEqualTo("SASL authentication failed")
     }
@@ -479,10 +471,9 @@ class RealImapConnectionTest {
         }
         val imapConnection = startServerAndCreateImapConnection(server, authType = AuthType.XOAUTH2)
 
-        assertThat {
+        assertFailure {
             imapConnection.open()
-        }.isFailure()
-            .isInstanceOf(AuthenticationFailedException::class)
+        }.isInstanceOf<AuthenticationFailedException>()
             .prop(AuthenticationFailedException::messageFromServer)
             .isEqualTo("SASL authentication failed")
     }
@@ -530,10 +521,9 @@ class RealImapConnectionTest {
         val imapConnection = startServerAndCreateImapConnection(server, authType = AuthType.EXTERNAL)
 
         // FIXME: improve exception message
-        assertThat {
+        assertFailure {
             imapConnection.open()
-        }.isFailure()
-            .isInstanceOf(CertificateValidationException::class)
+        }.isInstanceOf<CertificateValidationException>()
             .message().isNotNull().contains("Bad certificate")
 
         server.verifyConnectionClosed()
@@ -547,10 +537,9 @@ class RealImapConnectionTest {
         }
         val imapConnection = startServerAndCreateImapConnection(server, authType = AuthType.EXTERNAL)
 
-        assertThat {
+        assertFailure {
             imapConnection.open()
-        }.isFailure()
-            .isInstanceOf(CertificateValidationException::class)
+        }.isInstanceOf<CertificateValidationException>()
             .prop(CertificateValidationException::getReason)
             .isEqualTo(CertificateValidationException.Reason.MissingCapability)
 
@@ -652,10 +641,9 @@ class RealImapConnectionTest {
         val settings = createImapSettings(host = "host name")
         val imapConnection = createImapConnection(settings, socketFactory, oAuth2TokenProvider)
 
-        assertThat {
+        assertFailure {
             imapConnection.open()
-        }.isFailure()
-            .isInstanceOf(UnknownHostException::class)
+        }.isInstanceOf<UnknownHostException>()
 
         assertThat(imapConnection.isConnected).isFalse()
     }
@@ -699,10 +687,9 @@ class RealImapConnectionTest {
         )
 
         // FIXME: CertificateValidationException seems wrong
-        assertThat {
+        assertFailure {
             imapConnection.open()
-        }.isFailure()
-            .isInstanceOf(CertificateValidationException::class)
+        }.isInstanceOf<CertificateValidationException>()
             .hasMessage("STARTTLS connection security not available")
 
         server.verifyConnectionClosed()
@@ -749,10 +736,9 @@ class RealImapConnectionTest {
             authType = AuthType.PLAIN,
         )
 
-        assertThat {
+        assertFailure {
             imapConnection.open()
-        }.isFailure()
-            .isInstanceOf(NegativeImapResponseException::class)
+        }.isInstanceOf<NegativeImapResponseException>()
             .hasMessage("Command: STARTTLS; response: #2# [NO]")
 
         server.verifyConnectionClosed()
@@ -801,10 +787,9 @@ class RealImapConnectionTest {
         }
         val imapConnection = startServerAndCreateImapConnection(server, useCompression = true)
 
-        assertThat {
+        assertFailure {
             imapConnection.open()
-        }.isFailure()
-            .isInstanceOf(IOException::class)
+        }.isInstanceOf<IOException>()
 
         server.verifyConnectionClosed()
         server.verifyInteractionCompleted()
@@ -819,10 +804,9 @@ class RealImapConnectionTest {
         }
         val imapConnection = startServerAndCreateImapConnection(server)
 
-        assertThat {
+        assertFailure {
             imapConnection.open()
-        }.isFailure()
-            .isInstanceOf(IOException::class)
+        }.isInstanceOf<IOException>()
 
         server.verifyConnectionClosed()
         server.verifyInteractionCompleted()
@@ -1058,11 +1042,10 @@ class RealImapConnectionTest {
         }
         val imapConnection = startServerAndCreateImapConnection(server)
 
-        assertThat {
+        assertFailure {
             imapConnection.executeSimpleCommand("CREATE Folder")
-        }.isFailure()
-            .isInstanceOf(NegativeImapResponseException::class)
-            .prop(NegativeImapResponseException::getLastResponse)
+        }.isInstanceOf<NegativeImapResponseException>()
+            .prop(NegativeImapResponseException::lastResponse)
             .containsExactly("NO", "Folder exists")
 
         server.verifyConnectionStillOpen()
@@ -1100,10 +1083,9 @@ class RealImapConnectionTest {
         }
         val imapConnection = startServerAndCreateImapConnection(server)
 
-        assertThat {
+        assertFailure {
             imapConnection.open()
-        }.isFailure()
-            .isInstanceOf(AuthenticationFailedException::class)
+        }.isInstanceOf<AuthenticationFailedException>()
             .prop(AuthenticationFailedException::messageFromServer)
             .isEqualTo("AUTHENTICATE failed")
 
@@ -1210,7 +1192,7 @@ class RealImapConnectionTest {
 class TestTokenProvider : OAuth2TokenProvider {
     private var invalidationCount = 0
 
-    override fun getToken(email: String?, timeoutMillis: Long): String {
+    override fun getToken(timeoutMillis: Long): String {
         assertThat(timeoutMillis).isEqualTo(OAuth2TokenProvider.OAUTH2_TIMEOUT.toLong())
 
         return when (invalidationCount) {
diff --git a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapFolderIdlerTest.kt b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapFolderIdlerTest.kt
index 3e9862379a1936d6cdbedaa70aab808efeb4d3e4..45f21aa4104d616b692eceb7faa6e3014ac6c37a 100644
--- a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapFolderIdlerTest.kt
+++ b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapFolderIdlerTest.kt
@@ -1,9 +1,9 @@
 package com.fsck.k9.mail.store.imap
 
+import assertk.assertFailure
 import assertk.assertThat
 import assertk.assertions.hasMessage
 import assertk.assertions.isEqualTo
-import assertk.assertions.isFailure
 import assertk.assertions.isFalse
 import assertk.assertions.isGreaterThan
 import assertk.assertions.isInstanceOf
@@ -224,10 +224,9 @@ class RealImapFolderIdlerTest {
         imapFolder.throwOnOpen { throw AuthenticationFailedException("Authentication failure for test") }
 
         thread {
-            assertThat {
+            assertFailure {
                 idler.idle()
-            }.isFailure()
-                .isInstanceOf(AuthenticationFailedException::class)
+            }.isInstanceOf<AuthenticationFailedException>()
                 .hasMessage("Authentication failure for test")
 
             latch.countDown()
@@ -243,10 +242,9 @@ class RealImapFolderIdlerTest {
         imapFolder.throwOnOpen { throw IOException("I/O error for test") }
 
         thread {
-            assertThat {
+            assertFailure {
                 idler.idle()
-            }.isFailure()
-                .isInstanceOf(IOException::class)
+            }.isInstanceOf<IOException>()
                 .hasMessage("I/O error for test")
 
             latch.countDown()
@@ -261,10 +259,9 @@ class RealImapFolderIdlerTest {
         val latch = CountDownLatch(1)
 
         thread {
-            assertThat {
+            assertFailure {
                 idler.idle()
-            }.isFailure()
-                .isInstanceOf(IOException::class)
+            }.isInstanceOf<IOException>()
                 .hasMessage("Socket closed during IDLE")
 
             latch.countDown()
diff --git a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapFolderTest.kt b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapFolderTest.kt
index c2427ac35e090c106d31552d28e4492f4c3ba40d..c87615f2c8da3eae90cb8db7719339f00a9e2083 100644
--- a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapFolderTest.kt
+++ b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapFolderTest.kt
@@ -1,14 +1,20 @@
 package com.fsck.k9.mail.store.imap
 
 import assertk.all
+import assertk.assertFailure
 import assertk.assertThat
 import assertk.assertions.cause
 import assertk.assertions.containsExactly
+import assertk.assertions.containsOnly
+import assertk.assertions.extracting
 import assertk.assertions.hasMessage
 import assertk.assertions.isEqualTo
-import assertk.assertions.isFailure
+import assertk.assertions.isFalse
 import assertk.assertions.isInstanceOf
 import assertk.assertions.isNotNull
+import assertk.assertions.isNull
+import assertk.assertions.isTrue
+import assertk.fail
 import com.fsck.k9.mail.Body
 import com.fsck.k9.mail.DefaultBodyFactory
 import com.fsck.k9.mail.FetchProfile
@@ -27,12 +33,6 @@ import java.util.TimeZone
 import okio.Buffer
 import org.apache.james.mime4j.util.MimeUtil
 import org.junit.After
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertFalse
-import org.junit.Assert.assertNotNull
-import org.junit.Assert.assertNull
-import org.junit.Assert.assertTrue
-import org.junit.Assert.fail
 import org.junit.Before
 import org.junit.Test
 import org.mockito.ArgumentMatchers.anySet
@@ -79,7 +79,7 @@ class RealImapFolderTest {
 
         imapFolder.open(OpenMode.READ_WRITE)
 
-        assertTrue(imapFolder.isOpen)
+        assertThat(imapFolder.isOpen).isTrue()
     }
 
     @Test
@@ -89,7 +89,7 @@ class RealImapFolderTest {
 
         imapFolder.open(OpenMode.READ_ONLY)
 
-        assertTrue(imapFolder.isOpen)
+        assertThat(imapFolder.isOpen).isTrue()
     }
 
     @Test
@@ -99,7 +99,7 @@ class RealImapFolderTest {
 
         imapFolder.open(OpenMode.READ_WRITE)
 
-        assertEquals(23, imapFolder.messageCount)
+        assertThat(imapFolder.messageCount).isEqualTo(23)
     }
 
     @Test
@@ -109,7 +109,7 @@ class RealImapFolderTest {
 
         imapFolder.open(OpenMode.READ_WRITE)
 
-        assertEquals(OpenMode.READ_WRITE, imapFolder.mode)
+        assertThat(imapFolder.mode).isEqualTo(OpenMode.READ_WRITE)
     }
 
     @Test
@@ -119,7 +119,7 @@ class RealImapFolderTest {
 
         imapFolder.open(OpenMode.READ_ONLY)
 
-        assertEquals(OpenMode.READ_ONLY, imapFolder.mode)
+        assertThat(imapFolder.mode).isEqualTo(OpenMode.READ_ONLY)
     }
 
     @Test
@@ -129,7 +129,7 @@ class RealImapFolderTest {
 
         imapFolder.open(OpenMode.READ_WRITE)
 
-        assertTrue(imapFolder.exists())
+        assertThat(imapFolder.exists()).isTrue()
         verify(imapConnection, times(1)).executeSimpleCommand(anyString())
     }
 
@@ -161,10 +161,10 @@ class RealImapFolderTest {
         val imapFolder = createFolder("Folder")
         doThrow(IOException::class).whenever(imapConnection).executeSimpleCommand("SELECT \"Folder\"")
 
-        assertThat {
+        assertFailure {
             imapFolder.open(OpenMode.READ_WRITE)
-        }.isFailure()
-            .isInstanceOf(MessagingException::class).cause().isNotNull().isInstanceOf(IOException::class)
+        }.isInstanceOf<MessagingException>()
+            .cause().isNotNull().isInstanceOf<IOException>()
     }
 
     @Test
@@ -172,10 +172,9 @@ class RealImapFolderTest {
         val imapFolder = createFolder("Folder")
         doThrow(MessagingException::class).whenever(imapConnection).executeSimpleCommand("SELECT \"Folder\"")
 
-        assertThat {
+        assertFailure {
             imapFolder.open(OpenMode.READ_WRITE)
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
     }
 
     @Test
@@ -187,10 +186,9 @@ class RealImapFolderTest {
         )
         whenever(imapConnection.executeSimpleCommand("SELECT \"Folder\"")).thenReturn(selectResponses)
 
-        assertThat {
+        assertFailure {
             imapFolder.open(OpenMode.READ_WRITE)
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("Did not find message count during open")
     }
 
@@ -202,7 +200,7 @@ class RealImapFolderTest {
 
         imapFolder.close()
 
-        assertFalse(imapFolder.isOpen)
+        assertThat(imapFolder.isOpen).isFalse()
     }
 
     @Test
@@ -220,7 +218,7 @@ class RealImapFolderTest {
 
         val folderExists = imapFolder.exists()
 
-        assertTrue(folderExists)
+        assertThat(folderExists).isTrue()
     }
 
     @Test
@@ -231,7 +229,7 @@ class RealImapFolderTest {
 
         val folderExists = imapFolder.exists()
 
-        assertFalse(folderExists)
+        assertThat(folderExists).isFalse()
     }
 
     @Test
@@ -249,7 +247,7 @@ class RealImapFolderTest {
 
         val success = imapFolder.create()
 
-        assertTrue(success)
+        assertThat(success).isTrue()
     }
 
     @Test
@@ -259,7 +257,7 @@ class RealImapFolderTest {
 
         val success = imapFolder.create()
 
-        assertFalse(success)
+        assertThat(success).isFalse()
     }
 
     @Test
@@ -270,7 +268,7 @@ class RealImapFolderTest {
 
         val uidMapping = sourceFolder.copyMessages(messages, destinationFolder)
 
-        assertNull(uidMapping)
+        assertThat(uidMapping).isNull()
     }
 
     @Test
@@ -279,10 +277,9 @@ class RealImapFolderTest {
         val destinationFolder = createFolder("Destination")
         val messages = listOf(mock<ImapMessage>())
 
-        assertThat {
+        assertFailure {
             sourceFolder.copyMessages(messages, destinationFolder)
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("Folder Source is not open.")
     }
 
@@ -297,8 +294,7 @@ class RealImapFolderTest {
 
         val uidMapping = sourceFolder.copyMessages(messages, destinationFolder)
 
-        assertNotNull(uidMapping)
-        assertEquals("101", uidMapping!!["1"])
+        assertThat(uidMapping).isNotNull().containsOnly("1" to "101")
     }
 
     @Test
@@ -312,8 +308,7 @@ class RealImapFolderTest {
 
         val uidMapping = sourceFolder.moveMessages(messages, destinationFolder)
 
-        assertNotNull(uidMapping)
-        assertEquals("101", uidMapping!!["1"])
+        assertThat(uidMapping).isNotNull().containsOnly("1" to "101")
     }
 
     @Test
@@ -337,17 +332,16 @@ class RealImapFolderTest {
 
         val uidMapping = sourceFolder.moveMessages(messages, destinationFolder)
 
-        assertNull(uidMapping)
+        assertThat(uidMapping).isNull()
     }
 
     @Test
     fun getUnreadMessageCount_withClosedFolder_shouldThrow() {
         val folder = createFolder("FolderName")
 
-        assertThat {
+        assertFailure {
             folder.unreadMessageCount
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("Folder FolderName is not open.")
     }
 
@@ -358,10 +352,9 @@ class RealImapFolderTest {
         whenever(imapConnection.executeSimpleCommand("SEARCH 1:* UNSEEN NOT DELETED")).thenThrow(IOException())
         folder.open(OpenMode.READ_WRITE)
 
-        assertThat {
+        assertFailure {
             folder.unreadMessageCount
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("IO Error")
     }
 
@@ -375,17 +368,16 @@ class RealImapFolderTest {
 
         val unreadMessageCount = folder.unreadMessageCount
 
-        assertEquals(3, unreadMessageCount)
+        assertThat(unreadMessageCount).isEqualTo(3)
     }
 
     @Test
     fun getFlaggedMessageCount_withClosedFolder_shouldThrow() {
         val folder = createFolder("FolderName")
 
-        assertThat {
+        assertFailure {
             folder.flaggedMessageCount
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("Folder FolderName is not open.")
     }
 
@@ -402,7 +394,7 @@ class RealImapFolderTest {
 
         val flaggedMessageCount = folder.flaggedMessageCount
 
-        assertEquals(4, flaggedMessageCount)
+        assertThat(flaggedMessageCount).isEqualTo(4)
     }
 
     @Test
@@ -414,7 +406,7 @@ class RealImapFolderTest {
 
         val highestUid = folder.highestUid
 
-        assertEquals(42L, highestUid)
+        assertThat(highestUid).isEqualTo(42L)
     }
 
     @Test
@@ -426,7 +418,7 @@ class RealImapFolderTest {
 
         val highestUid = folder.highestUid
 
-        assertEquals(-1L, highestUid)
+        assertThat(highestUid).isEqualTo(-1L)
     }
 
     @Test
@@ -436,10 +428,9 @@ class RealImapFolderTest {
         doThrow(IOException::class).whenever(imapConnection).executeSimpleCommand("UID SEARCH *:*")
         folder.open(OpenMode.READ_WRITE)
 
-        assertThat {
+        assertFailure {
             folder.highestUid
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("IO Error")
     }
 
@@ -452,8 +443,8 @@ class RealImapFolderTest {
 
         val messages = folder.getMessages(1, 10, null, null)
 
-        assertNotNull(messages)
-        assertEquals(setOf("3", "5", "6"), extractMessageUids(messages))
+        assertThat(messages).isNotNull()
+            .extracting { it.uid }.containsOnly("3", "5", "6")
     }
 
     @Test
@@ -466,8 +457,8 @@ class RealImapFolderTest {
 
         val messages = folder.getMessages(1, 10, Date(1454719826000L), null)
 
-        assertNotNull(messages)
-        assertEquals(setOf("18", "47"), extractMessageUids(messages))
+        assertThat(messages).isNotNull()
+            .extracting { it.uid }.containsOnly("18", "47")
     }
 
     @Test
@@ -488,10 +479,9 @@ class RealImapFolderTest {
     fun getMessages_withInvalidStartArgument_shouldThrow() {
         val folder = createFolder("Folder")
 
-        assertThat {
+        assertFailure {
             folder.getMessages(0, 10, null, null)
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("Invalid message set 0 10")
     }
 
@@ -499,10 +489,9 @@ class RealImapFolderTest {
     fun getMessages_withInvalidEndArgument_shouldThrow() {
         val folder = createFolder("Folder")
 
-        assertThat {
+        assertFailure {
             folder.getMessages(10, 0, null, null)
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("Invalid message set 10 0")
     }
 
@@ -510,10 +499,9 @@ class RealImapFolderTest {
     fun getMessages_withEndArgumentSmallerThanStartArgument_shouldThrow() {
         val folder = createFolder("Folder")
 
-        assertThat {
+        assertFailure {
             folder.getMessages(10, 5, null, null)
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("Invalid message set 10 5")
     }
 
@@ -521,10 +509,9 @@ class RealImapFolderTest {
     fun getMessages_withClosedFolder_shouldThrow() {
         val folder = createFolder("FolderName")
 
-        assertThat {
+        assertFailure {
             folder.getMessages(1, 5, null, null)
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("Folder FolderName is not open.")
     }
 
@@ -532,10 +519,9 @@ class RealImapFolderTest {
     fun getMessages_sequenceNumbers_withClosedFolder_shouldThrow() {
         val folder = createFolder("FolderName")
 
-        assertThat {
+        assertFailure {
             folder.getMessages(setOf(1L, 2L, 5L), false, null)
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("Folder FolderName is not open.")
     }
 
@@ -548,8 +534,8 @@ class RealImapFolderTest {
 
         val messages = folder.getMessages(setOf(1L, 2L, 5L), false, null)
 
-        assertNotNull(messages)
-        assertEquals(setOf("17", "18", "49"), extractMessageUids(messages))
+        assertThat(messages).isNotNull()
+            .extracting { it.uid }.containsOnly("17", "18", "49")
     }
 
     @Test
@@ -570,10 +556,9 @@ class RealImapFolderTest {
     fun getMessagesFromUids_withClosedFolder_shouldThrow() {
         val folder = createFolder("FolderName")
 
-        assertThat {
+        assertFailure {
             folder.getMessagesFromUids(listOf("11", "22", "25"))
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("Folder FolderName is not open.")
     }
 
@@ -586,18 +571,17 @@ class RealImapFolderTest {
 
         val messages = folder.getMessagesFromUids(listOf("11", "22", "25"))
 
-        assertNotNull(messages)
-        assertEquals(setOf("11", "22", "25"), extractMessageUids(messages))
+        assertThat(messages).isNotNull()
+            .extracting { it.uid }.containsOnly("11", "22", "25")
     }
 
     @Test
     fun areMoreMessagesAvailable_withClosedFolder_shouldThrow() {
         val folder = createFolder("FolderName")
 
-        assertThat {
+        assertFailure {
             folder.areMoreMessagesAvailable(10, Date())
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("Folder FolderName is not open.")
     }
 
@@ -610,7 +594,7 @@ class RealImapFolderTest {
 
         val areMoreMessagesAvailable = folder.areMoreMessagesAvailable(10, null)
 
-        assertTrue(areMoreMessagesAvailable)
+        assertThat(areMoreMessagesAvailable).isTrue()
     }
 
     @Test
@@ -622,7 +606,7 @@ class RealImapFolderTest {
 
         val areMoreMessagesAvailable = folder.areMoreMessagesAvailable(600, null)
 
-        assertFalse(areMoreMessagesAvailable)
+        assertThat(areMoreMessagesAvailable).isFalse()
     }
 
     @Test
@@ -633,7 +617,7 @@ class RealImapFolderTest {
 
         val areMoreMessagesAvailable = folder.areMoreMessagesAvailable(1, null)
 
-        assertFalse(areMoreMessagesAvailable)
+        assertThat(areMoreMessagesAvailable).isFalse()
         // SELECT during OPEN and no more
         verify(imapConnection, times(1)).executeSimpleCommand(anyString())
     }
@@ -689,7 +673,7 @@ class RealImapFolderTest {
         verify(imapConnection).sendCommand(
             "UID FETCH 1 (UID INTERNALDATE RFC822.SIZE BODY.PEEK[HEADER.FIELDS " +
                 "(date subject from content-type to cc bcc reply-to message-id references in-reply-to " +
-                "list-unsubscribe sender X-K9mail-Identity Chat-Version)])",
+                "list-post list-unsubscribe sender X-K9mail-Identity Chat-Version)])",
             false,
         )
     }
@@ -922,7 +906,7 @@ class RealImapFolderTest {
         val body = bodyArgumentCaptor.firstValue
         val buffer = Buffer()
         body.writeTo(buffer.outputStream())
-        assertEquals("text", buffer.readUtf8())
+        assertThat(buffer.readUtf8()).isEqualTo("text")
     }
 
     @Test
@@ -946,13 +930,12 @@ class RealImapFolderTest {
         val messages = listOf(createImapMessage("1"))
         whenever(imapConnection.readResponse()).thenReturn(createImapResponse("x NO Can't append to this folder"))
 
-        assertThat {
+        assertFailure {
             folder.appendMessages(messages)
-        }.isFailure()
-            .isInstanceOf(NegativeImapResponseException::class.java).all {
-                hasMessage("APPEND failed")
-                transform { it.lastResponse[0] }.isEqualTo("NO")
-            }
+        }.isInstanceOf<NegativeImapResponseException>().all {
+            hasMessage("APPEND failed")
+            transform { it.lastResponse[0] }.isEqualTo("NO")
+        }
     }
 
     @Test
@@ -963,13 +946,12 @@ class RealImapFolderTest {
         val messages = listOf(createImapMessage("1"))
         whenever(imapConnection.readResponse()).thenReturn(createImapResponse("x BAD [TOOBIG] Message too large."))
 
-        assertThat {
+        assertFailure {
             folder.appendMessages(messages)
-        }.isFailure()
-            .isInstanceOf(NegativeImapResponseException::class.java).all {
-                hasMessage("APPEND failed")
-                transform { it.lastResponse[0] }.isEqualTo("BAD")
-            }
+        }.isInstanceOf<NegativeImapResponseException>().all {
+            hasMessage("APPEND failed")
+            transform { it.lastResponse[0] }.isEqualTo("BAD")
+        }
     }
 
     @Test
@@ -993,7 +975,7 @@ class RealImapFolderTest {
 
         val uid = folder.getUidFromMessageId("<00000000.0000000@example.org>")
 
-        assertEquals("23", uid)
+        assertThat(uid).isEqualTo("23")
     }
 
     @Test
@@ -1066,7 +1048,7 @@ class RealImapFolderTest {
 
         val message = folder.getMessage("uid")
 
-        assertEquals("uid", message.uid)
+        assertThat(message.uid).isEqualTo("uid")
     }
 
     @Suppress("SameParameterValue")
@@ -1103,8 +1085,6 @@ class RealImapFolderTest {
         return response
     }
 
-    private fun extractMessageUids(messages: List<ImapMessage>) = messages.map { it.uid }.toSet()
-
     private fun createFolder(folderName: String): RealImapFolder {
         return RealImapFolder(internalImapStore, testConnectionManager, folderName, FolderNameCodec())
     }
diff --git a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapStoreTest.kt b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapStoreTest.kt
index 04c9af4f9a409e5f9e4afcd8b9080a2e42de4b93..cda5d6e10b15affa95076ea56acca39877d732ca 100644
--- a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapStoreTest.kt
+++ b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/RealImapStoreTest.kt
@@ -1,11 +1,11 @@
 package com.fsck.k9.mail.store.imap
 
 import assertk.all
+import assertk.assertFailure
 import assertk.assertThat
 import assertk.assertions.cause
 import assertk.assertions.containsExactly
 import assertk.assertions.hasMessage
-import assertk.assertions.isFailure
 import assertk.assertions.isInstanceOf
 import assertk.assertions.isNotNull
 import assertk.assertions.isSameAs
@@ -50,11 +50,12 @@ class RealImapStoreTest {
         }
         imapStore.enqueueImapConnection(imapConnection)
 
-        assertThat { imapStore.checkSettings() }.isFailure()
-            .isInstanceOf(MessagingException::class).all {
-                hasMessage("Unable to connect")
-                cause().isNotNull().isInstanceOf(IOException::class)
-            }
+        assertFailure {
+            imapStore.checkSettings()
+        }.isInstanceOf<MessagingException>().all {
+            hasMessage("Unable to connect")
+            cause().isNotNull().isInstanceOf<IOException>()
+        }
     }
 
     @Test
@@ -249,8 +250,9 @@ class RealImapStoreTest {
         }
         imapStore.enqueueImapConnection(imapConnection)
 
-        assertThat { imapStore.getFolders() }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        assertFailure {
+            imapStore.getFolders()
+        }.isInstanceOf<MessagingException>()
 
         verify(imapConnection).close()
     }
@@ -385,18 +387,21 @@ class RealImapStoreTest {
             username = "user",
             password = "password",
             clientCertificateAlias = null,
-            extra = createExtra(autoDetectNamespace = true, pathPrefix = null),
+            extra = createExtra(
+                autoDetectNamespace = true,
+                pathPrefix = null,
+                useCompression = false,
+                sendClientId = false,
+            ),
         )
     }
 
     private fun createTestImapStore(
         isSubscribedFoldersOnly: Boolean = false,
-        useCompression: Boolean = false,
-        clientIdAppName: String? = null,
     ): TestImapStore {
         return TestImapStore(
             serverSettings = createServerSettings(),
-            config = createImapStoreConfig(isSubscribedFoldersOnly, useCompression, clientIdAppName),
+            config = createImapStoreConfig(isSubscribedFoldersOnly),
             trustedSocketFactory = mock(),
             oauth2TokenProvider = null,
         )
@@ -404,14 +409,11 @@ class RealImapStoreTest {
 
     private fun createImapStoreConfig(
         isSubscribedFoldersOnly: Boolean,
-        useCompression: Boolean,
-        clientIdAppName: String?,
     ): ImapStoreConfig {
         return object : ImapStoreConfig {
             override val logLabel: String = "irrelevant"
             override fun isSubscribedFoldersOnly(): Boolean = isSubscribedFoldersOnly
-            override fun useCompression(): Boolean = useCompression
-            override fun clientIdAppName(): String? = clientIdAppName
+            override fun clientIdAppName(): String = "irrelevant"
         }
     }
 
diff --git a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/UidValidityResponseTest.kt b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/UidValidityResponseTest.kt
index 9d6f84227415b7e79475acb53d69c2321f2718aa..46acef0e0109802fa2ec26169cdfeabe16cc5211 100644
--- a/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/UidValidityResponseTest.kt
+++ b/mail/protocols/imap/src/test/java/com/fsck/k9/mail/store/imap/UidValidityResponseTest.kt
@@ -1,8 +1,10 @@
 package com.fsck.k9.mail.store.imap
 
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNotNull
-import org.junit.Assert.assertNull
+import assertk.assertThat
+import assertk.assertions.isEqualTo
+import assertk.assertions.isNotNull
+import assertk.assertions.isNull
+import assertk.assertions.prop
 import org.junit.Test
 
 class UidValidityResponseTest {
@@ -12,8 +14,8 @@ class UidValidityResponseTest {
 
         val result = UidValidityResponse.parse(response)
 
-        assertNotNull(result)
-        assertEquals(23, result!!.uidValidity)
+        assertThat(result).isNotNull()
+            .prop(UidValidityResponse::uidValidity).isEqualTo(23)
     }
 
     @Test
@@ -22,8 +24,8 @@ class UidValidityResponseTest {
 
         val result = UidValidityResponse.parse(response)
 
-        assertNotNull(result)
-        assertEquals(42, result!!.uidValidity)
+        assertThat(result).isNotNull()
+            .prop(UidValidityResponse::uidValidity).isEqualTo(42)
     }
 
     @Test
@@ -58,6 +60,7 @@ class UidValidityResponseTest {
 
     private fun assertNotValid(response: String) {
         val result = UidValidityResponse.parse(ImapResponseHelper.createImapResponse(response))
-        assertNull(result)
+
+        assertThat(result).isNull()
     }
 }
diff --git a/mail/protocols/pop3/src/main/java/com/fsck/k9/mail/store/pop3/Pop3Connection.java b/mail/protocols/pop3/src/main/java/com/fsck/k9/mail/store/pop3/Pop3Connection.java
index 4badc73e5fda82cda734375c7ff0a0e359481198..bbcca763081b1d5893450ffbf592409f494b8f36 100644
--- a/mail/protocols/pop3/src/main/java/com/fsck/k9/mail/store/pop3/Pop3Connection.java
+++ b/mail/protocols/pop3/src/main/java/com/fsck/k9/mail/store/pop3/Pop3Connection.java
@@ -91,6 +91,7 @@ class Pop3Connection {
             throw new MessagingException(
                     "Unable to open connection to POP server due to security error.", gse);
         } catch (IOException ioe) {
+            close();
             throw new MessagingException("Unable to open connection to POP server.", ioe);
         }
     }
@@ -165,7 +166,7 @@ class Pop3Connection {
     }
 
     private void performAuthentication(AuthType authType, String serverGreeting)
-            throws MessagingException {
+            throws MessagingException, IOException {
         switch (authType) {
             case PLAIN:
                 if (capabilities.authPlain) {
@@ -250,30 +251,27 @@ class Pop3Connection {
         return capabilities;
     }
 
-    private void login() throws MessagingException {
+    private void login() throws MessagingException, IOException {
         executeSimpleCommand(USER_COMMAND + " " + settings.getUsername());
         try {
             executeSimpleCommand(PASS_COMMAND + " " + settings.getPassword(), true);
         } catch (Pop3ErrorResponse e) {
-            throw new AuthenticationFailedException(
-                    "POP3 login authentication failed: " + e.getMessage(), e);
+            throw new AuthenticationFailedException("USER/PASS failed", e, e.getResponseText());
         }
     }
 
-    private void authPlain() throws MessagingException {
+    private void authPlain() throws MessagingException, IOException {
         executeSimpleCommand("AUTH PLAIN");
         try {
             byte[] encodedBytes = Base64.encodeBase64(("\000" + settings.getUsername()
                     + "\000" + settings.getPassword()).getBytes());
             executeSimpleCommand(new String(encodedBytes), true);
         } catch (Pop3ErrorResponse e) {
-            throw new AuthenticationFailedException(
-                    "POP3 SASL auth PLAIN authentication failed: "
-                            + e.getMessage(), e);
+            throw new AuthenticationFailedException("AUTH PLAIN failed", e, e.getResponseText());
         }
     }
 
-    private void authAPOP(String serverGreeting) throws MessagingException {
+    private void authAPOP(String serverGreeting) throws MessagingException, IOException {
         // regex based on RFC 2449 (3.) "Greeting"
         String timestamp = serverGreeting.replaceFirst(
                 "^\\+OK *(?:\\[[^\\]]+\\])?[^<]*(<[^>]*>)?[^<]*$", "$1");
@@ -293,25 +291,22 @@ class Pop3Connection {
         try {
             executeSimpleCommand("APOP " + settings.getUsername() + " " + hexDigest, true);
         } catch (Pop3ErrorResponse e) {
-            throw new AuthenticationFailedException(
-                    "POP3 APOP authentication failed: " + e.getMessage(), e);
+            throw new AuthenticationFailedException("APOP failed", e, e.getResponseText());
         }
     }
 
-    private void authCramMD5() throws MessagingException {
+    private void authCramMD5() throws MessagingException, IOException {
         String b64Nonce = executeSimpleCommand("AUTH CRAM-MD5").replace("+ ", "");
 
         String b64CRAM = Authentication.computeCramMd5(settings.getUsername(), settings.getPassword(), b64Nonce);
         try {
             executeSimpleCommand(b64CRAM, true);
         } catch (Pop3ErrorResponse e) {
-            throw new AuthenticationFailedException(
-                    "POP3 CRAM-MD5 authentication failed: "
-                            + e.getMessage(), e);
+            throw new AuthenticationFailedException("AUTH CRAM-MD5 failed", e, e.getResponseText());
         }
     }
 
-    private void authExternal() throws MessagingException {
+    private void authExternal() throws MessagingException, IOException {
         try {
             executeSimpleCommand(
                     String.format("AUTH EXTERNAL %s",
@@ -336,36 +331,29 @@ class Pop3Connection {
         out.flush();
     }
 
-    String executeSimpleCommand(String command) throws MessagingException {
+    String executeSimpleCommand(String command) throws IOException, Pop3ErrorResponse {
         return executeSimpleCommand(command, false);
     }
 
-    private String executeSimpleCommand(String command, boolean sensitive) throws MessagingException {
-        try {
-            if (command != null) {
-                if (K9MailLib.isDebug() && DEBUG_PROTOCOL_POP3) {
-                    if (sensitive && !K9MailLib.isDebugSensitive()) {
-                        Timber.d(">>> [Command Hidden, Enable Sensitive Debug Logging To Show]");
-                    } else {
-                        Timber.d(">>> %s", command);
-                    }
+    private String executeSimpleCommand(String command, boolean sensitive) throws IOException, Pop3ErrorResponse {
+        if (command != null) {
+            if (K9MailLib.isDebug() && DEBUG_PROTOCOL_POP3) {
+                if (sensitive && !K9MailLib.isDebugSensitive()) {
+                    Timber.d(">>> [Command Hidden, Enable Sensitive Debug Logging To Show]");
+                } else {
+                    Timber.d(">>> %s", command);
                 }
-
-                writeLine(command);
             }
 
-            String response = readLine();
-            if (response.length() == 0 || response.charAt(0) != '+') {
-                throw new Pop3ErrorResponse(response);
-            }
+            writeLine(command);
+        }
 
-            return response;
-        } catch (MessagingException me) {
-            throw me;
-        } catch (Exception e) {
-            close();
-            throw new MessagingException("Unable to execute POP3 command", e);
+        String response = readLine();
+        if (response.length() == 0 || response.charAt(0) != '+') {
+            throw new Pop3ErrorResponse(response);
         }
+
+        return response;
     }
 
     String readLine() throws IOException {
diff --git a/mail/protocols/pop3/src/main/java/com/fsck/k9/mail/store/pop3/Pop3ErrorResponse.java b/mail/protocols/pop3/src/main/java/com/fsck/k9/mail/store/pop3/Pop3ErrorResponse.java
index fa3d652aa85773d5f543145be86a7f2bde98c253..818c08cde528d3729ebed71d91a97d0ec3ac37b0 100644
--- a/mail/protocols/pop3/src/main/java/com/fsck/k9/mail/store/pop3/Pop3ErrorResponse.java
+++ b/mail/protocols/pop3/src/main/java/com/fsck/k9/mail/store/pop3/Pop3ErrorResponse.java
@@ -13,4 +13,9 @@ class Pop3ErrorResponse extends MessagingException {
     public Pop3ErrorResponse(String message) {
         super(message, true);
     }
+
+    public String getResponseText() {
+        // TODO: Extract response text from response line
+        return getMessage();
+    }
 }
diff --git a/mail/protocols/pop3/src/main/java/com/fsck/k9/mail/store/pop3/Pop3Folder.java b/mail/protocols/pop3/src/main/java/com/fsck/k9/mail/store/pop3/Pop3Folder.java
index 3271626f906d52139efa21709d667b142004b947..5570da63767f96e041bb5a763eafcbea2be0a128 100644
--- a/mail/protocols/pop3/src/main/java/com/fsck/k9/mail/store/pop3/Pop3Folder.java
+++ b/mail/protocols/pop3/src/main/java/com/fsck/k9/mail/store/pop3/Pop3Folder.java
@@ -52,15 +52,19 @@ public class Pop3Folder {
         }
 
         connection = pop3Store.createConnection();
-        connection.open();
+        try {
+            connection.open();
 
-        String response = connection.executeSimpleCommand(STAT_COMMAND);
-        String[] parts = response.split(" ");
-        messageCount = Integer.parseInt(parts[1]);
+            String response = connection.executeSimpleCommand(STAT_COMMAND);
+            String[] parts = response.split(" ");
+            messageCount = Integer.parseInt(parts[1]);
 
-        uidToMsgMap.clear();
-        msgNumToMsgMap.clear();
-        uidToMsgNumMap.clear();
+            uidToMsgMap.clear();
+            msgNumToMsgMap.clear();
+            uidToMsgNumMap.clear();
+        } catch (IOException e) {
+            handleIOException(e);
+        }
     }
 
     public boolean isOpen() {
@@ -114,7 +118,7 @@ public class Pop3Folder {
         try {
             indexMsgNums(start, end);
         } catch (IOException ioe) {
-            throw new MessagingException("getMessages", ioe);
+            handleIOException(ioe);
         }
         List<Pop3Message> messages = new ArrayList<>();
         for (int msgNum = start; msgNum <= end; msgNum++) {
@@ -295,7 +299,7 @@ public class Pop3Folder {
         try {
             indexUids(uids);
         } catch (IOException ioe) {
-            throw new MessagingException("fetch", ioe);
+            handleIOException(ioe);
         }
         try {
             if (fp.contains(FetchProfile.Item.ENVELOPE)) {
@@ -308,7 +312,7 @@ public class Pop3Folder {
                 fetchEnvelope(messages, fp.size() == 1 ? listener : null);
             }
         } catch (IOException ioe) {
-            throw new MessagingException("fetch", ioe);
+            handleIOException(ioe);
         }
         for (Pop3Message pop3Message : messages) {
             try {
@@ -335,7 +339,7 @@ public class Pop3Folder {
                     listener.messageFinished(pop3Message);
                 }
             } catch (IOException ioe) {
-                throw new MessagingException("Unable to fetch message", ioe);
+                handleIOException(ioe);
             }
         }
     }
@@ -477,7 +481,7 @@ public class Pop3Folder {
 
             indexUids(uids);
         } catch (IOException ioe) {
-            throw new MessagingException("Could not get message number for uid " + uids, ioe);
+            handleIOException(ioe);
         }
         for (Pop3Message message : messages) {
 
@@ -489,7 +493,11 @@ public class Pop3Folder {
                 );
             }
             open();
-            connection.executeSimpleCommand(String.format(DELE_COMMAND + " %s", msgNum));
+            try {
+                connection.executeSimpleCommand(String.format(DELE_COMMAND + " %s", msgNum));
+            } catch (IOException e) {
+                handleIOException(e);
+            }
         }
     }
 
@@ -511,17 +519,31 @@ public class Pop3Folder {
     }
 
     void requestUidl() throws MessagingException {
-        if (!connection.supportsUidl()) {
-            /*
-             * Run an additional test to see if UIDL is supported on the server. If it's not we
-             * can't service this account.
-             */
+        try {
+            if (!connection.supportsUidl()) {
+                /*
+                 * Run an additional test to see if UIDL is supported on the server. If it's not we
+                 * can't service this account.
+                 */
 
-            /*
-             * If the server doesn't support UIDL it will return a - response, which causes
-             * executeSimpleCommand to throw a MessagingException, exiting this method.
-             */
-            connection.executeSimpleCommand(UIDL_COMMAND);
+                /*
+                 * If the server doesn't support UIDL it will return a - response, which causes
+                 * executeSimpleCommand to throw a MessagingException, exiting this method.
+                 */
+                connection.executeSimpleCommand(UIDL_COMMAND);
+            }
+        } catch (IOException e) {
+            handleIOException(e);
+        }
+    }
+
+    private void handleIOException(IOException exception) throws MessagingException {
+        Pop3Connection connection = this.connection;
+        if (connection != null) {
+            connection.close();
         }
+
+        // For now we wrap IOExceptions in a MessagingException
+        throw new MessagingException("I/O error", exception);
     }
 }
diff --git a/mail/protocols/pop3/src/main/java/com/fsck/k9/mail/store/pop3/Pop3ServerSettingsValidator.kt b/mail/protocols/pop3/src/main/java/com/fsck/k9/mail/store/pop3/Pop3ServerSettingsValidator.kt
new file mode 100644
index 0000000000000000000000000000000000000000..4dae41e9222e3b8934d6a3811027d2c9baec4a2c
--- /dev/null
+++ b/mail/protocols/pop3/src/main/java/com/fsck/k9/mail/store/pop3/Pop3ServerSettingsValidator.kt
@@ -0,0 +1,47 @@
+package com.fsck.k9.mail.store.pop3
+
+import com.fsck.k9.mail.AuthenticationFailedException
+import com.fsck.k9.mail.CertificateValidationException
+import com.fsck.k9.mail.MessagingException
+import com.fsck.k9.mail.ServerSettings
+import com.fsck.k9.mail.oauth.AuthStateStorage
+import com.fsck.k9.mail.server.ServerSettingsValidationResult
+import com.fsck.k9.mail.server.ServerSettingsValidator
+import com.fsck.k9.mail.ssl.TrustedSocketFactory
+import java.io.IOException
+
+class Pop3ServerSettingsValidator(
+    private val trustedSocketFactory: TrustedSocketFactory,
+) : ServerSettingsValidator {
+
+    @Suppress("TooGenericExceptionCaught")
+    override fun checkServerSettings(
+        serverSettings: ServerSettings,
+        authStateStorage: AuthStateStorage?,
+    ): ServerSettingsValidationResult {
+        val store = Pop3Store(serverSettings, trustedSocketFactory)
+
+        return try {
+            store.checkSettings()
+
+            ServerSettingsValidationResult.Success
+        } catch (e: AuthenticationFailedException) {
+            ServerSettingsValidationResult.AuthenticationError(e.messageFromServer)
+        } catch (e: CertificateValidationException) {
+            ServerSettingsValidationResult.CertificateError(e.certChain.toList())
+        } catch (e: Pop3ErrorResponse) {
+            ServerSettingsValidationResult.ServerError(e.responseText)
+        } catch (e: MessagingException) {
+            val cause = e.cause
+            if (cause is IOException) {
+                ServerSettingsValidationResult.NetworkError(cause)
+            } else {
+                ServerSettingsValidationResult.UnknownError(e)
+            }
+        } catch (e: IOException) {
+            ServerSettingsValidationResult.NetworkError(e)
+        } catch (e: Exception) {
+            ServerSettingsValidationResult.UnknownError(e)
+        }
+    }
+}
diff --git a/mail/protocols/pop3/src/main/java/com/fsck/k9/mail/store/pop3/Pop3Store.java b/mail/protocols/pop3/src/main/java/com/fsck/k9/mail/store/pop3/Pop3Store.java
index 4542caaedd44f0122249d6d49e8f4fe5e1db0c68..8c2e06132732083db23fbc4a1c2e42cc3bd71025 100644
--- a/mail/protocols/pop3/src/main/java/com/fsck/k9/mail/store/pop3/Pop3Store.java
+++ b/mail/protocols/pop3/src/main/java/com/fsck/k9/mail/store/pop3/Pop3Store.java
@@ -25,6 +25,10 @@ public class Pop3Store {
     private Map<String, Pop3Folder> mFolders = new HashMap<>();
 
     public Pop3Store(ServerSettings serverSettings, TrustedSocketFactory socketFactory) {
+        if (!serverSettings.type.equals("pop3")) {
+            throw new IllegalArgumentException("Expected POP3 ServerSettings");
+        }
+
         trustedSocketFactory = socketFactory;
         host = serverSettings.host;
         port = serverSettings.port;
diff --git a/mail/protocols/pop3/src/test/java/com/fsck/k9/mail/store/pop3/Pop3ConnectionTest.kt b/mail/protocols/pop3/src/test/java/com/fsck/k9/mail/store/pop3/Pop3ConnectionTest.kt
index 397745e3cc4bad359232ecc561b4bc6e3747814d..db1f483500e9d8f12f5a849f737c32ba4f9a1b47 100644
--- a/mail/protocols/pop3/src/test/java/com/fsck/k9/mail/store/pop3/Pop3ConnectionTest.kt
+++ b/mail/protocols/pop3/src/test/java/com/fsck/k9/mail/store/pop3/Pop3ConnectionTest.kt
@@ -1,9 +1,8 @@
 package com.fsck.k9.mail.store.pop3
 
-import assertk.assertThat
+import assertk.assertFailure
 import assertk.assertions.hasMessage
 import assertk.assertions.isEqualTo
-import assertk.assertions.isFailure
 import assertk.assertions.isInstanceOf
 import assertk.assertions.prop
 import com.fsck.k9.mail.AuthType
@@ -162,10 +161,9 @@ class Pop3ConnectionTest {
         }
         val settings = server.createSettings(authType = PLAIN)
 
-        assertThat {
+        assertFailure {
             createAndOpenPop3Connection(settings)
-        }.isFailure()
-            .isInstanceOf(AuthenticationFailedException::class)
+        }.isInstanceOf<AuthenticationFailedException>()
 
         server.verifyInteractionCompleted()
     }
@@ -197,10 +195,9 @@ class Pop3ConnectionTest {
         }
         val settings = server.createSettings(authType = PLAIN)
 
-        assertThat {
+        assertFailure {
             createAndOpenPop3Connection(settings)
-        }.isFailure()
-            .isInstanceOf(AuthenticationFailedException::class)
+        }.isInstanceOf<AuthenticationFailedException>()
 
         server.verifyInteractionCompleted()
     }
@@ -233,10 +230,9 @@ class Pop3ConnectionTest {
         }
         val settings = server.createSettings(authType = CRAM_MD5)
 
-        assertThat {
+        assertFailure {
             createAndOpenPop3Connection(settings)
-        }.isFailure()
-            .isInstanceOf(AuthenticationFailedException::class)
+        }.isInstanceOf<AuthenticationFailedException>()
 
         server.verifyInteractionCompleted()
     }
@@ -273,10 +269,9 @@ class Pop3ConnectionTest {
         }
         val settings = server.createSettings(authType = CRAM_MD5)
 
-        assertThat {
+        assertFailure {
             createAndOpenPop3Connection(settings)
-        }.isFailure()
-            .isInstanceOf(AuthenticationFailedException::class)
+        }.isInstanceOf<AuthenticationFailedException>()
 
         server.verifyInteractionCompleted()
     }
@@ -303,10 +298,9 @@ class Pop3ConnectionTest {
         }
         val settings = server.createSettings(authType = EXTERNAL)
 
-        assertThat {
+        assertFailure {
             createAndOpenPop3Connection(settings)
-        }.isFailure()
-            .isInstanceOf(CertificateValidationException::class.java)
+        }.isInstanceOf<CertificateValidationException>()
             .prop(CertificateValidationException::getReason)
             .isEqualTo(CertificateValidationException.Reason.MissingCapability)
 
@@ -323,10 +317,9 @@ class Pop3ConnectionTest {
         }
         val settings = server.createSettings(authType = EXTERNAL)
 
-        assertThat {
+        assertFailure {
             createAndOpenPop3Connection(settings)
-        }.isFailure()
-            .isInstanceOf(CertificateValidationException::class.java)
+        }.isInstanceOf<CertificateValidationException>()
             .hasMessage("POP3 client certificate authentication failed: -ERR Invalid certificate")
 
         server.verifyInteractionCompleted()
diff --git a/mail/protocols/pop3/src/test/java/com/fsck/k9/mail/store/pop3/Pop3FolderTest.kt b/mail/protocols/pop3/src/test/java/com/fsck/k9/mail/store/pop3/Pop3FolderTest.kt
index bcdf634c9909a707785c3b0fdad3a5825d07a8f7..b26f3defa70c30708f14e12a50492cb68b833c1c 100644
--- a/mail/protocols/pop3/src/test/java/com/fsck/k9/mail/store/pop3/Pop3FolderTest.kt
+++ b/mail/protocols/pop3/src/test/java/com/fsck/k9/mail/store/pop3/Pop3FolderTest.kt
@@ -89,7 +89,7 @@ class Pop3FolderTest {
     @Test(expected = MessagingException::class)
     fun `open() with STAT command failing should throw`() {
         stubbing(connection) {
-            on { executeSimpleCommand(STAT_COMMAND) } doThrow MessagingException("Test")
+            on { executeSimpleCommand(STAT_COMMAND) } doThrow Pop3ErrorResponse("Test")
         }
 
         folder.open()
@@ -136,7 +136,7 @@ class Pop3FolderTest {
     @Test
     fun `close() with exception when sending QUIT command should not throw`() {
         stubbing(connection) {
-            on { executeSimpleCommand(Pop3Commands.QUIT_COMMAND) } doThrow MessagingException("Test")
+            on { executeSimpleCommand(Pop3Commands.QUIT_COMMAND) } doThrow Pop3ErrorResponse("Test")
         }
         folder.open()
 
diff --git a/mail/protocols/pop3/src/test/java/com/fsck/k9/mail/store/pop3/Pop3ServerSettingsValidatorTest.kt b/mail/protocols/pop3/src/test/java/com/fsck/k9/mail/store/pop3/Pop3ServerSettingsValidatorTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..3200c4ee193ad3ddf88ff0f501a756507eaf3583
--- /dev/null
+++ b/mail/protocols/pop3/src/test/java/com/fsck/k9/mail/store/pop3/Pop3ServerSettingsValidatorTest.kt
@@ -0,0 +1,206 @@
+package com.fsck.k9.mail.store.pop3
+
+import assertk.assertFailure
+import assertk.assertThat
+import assertk.assertions.hasSize
+import assertk.assertions.isEqualTo
+import assertk.assertions.isInstanceOf
+import assertk.assertions.prop
+import com.fsck.k9.mail.AuthType
+import com.fsck.k9.mail.ConnectionSecurity
+import com.fsck.k9.mail.ServerSettings
+import com.fsck.k9.mail.helpers.FakeTrustManager
+import com.fsck.k9.mail.helpers.SimpleTrustedSocketFactory
+import com.fsck.k9.mail.server.ServerSettingsValidationResult
+import java.net.UnknownHostException
+import kotlin.test.Test
+
+private const val USERNAME = "user"
+private const val PASSWORD = "password"
+private val CLIENT_CERTIFICATE_ALIAS: String? = null
+
+class Pop3ServerSettingsValidatorTest {
+    private val fakeTrustManager = FakeTrustManager()
+    private val trustedSocketFactory = SimpleTrustedSocketFactory(fakeTrustManager)
+    private val serverSettingsValidator = Pop3ServerSettingsValidator(trustedSocketFactory)
+
+    @Test
+    fun `valid server settings should return Success`() {
+        val server = startServer {
+            output("+OK POP3 server greeting")
+            expect("CAPA")
+            output("+OK Listing of supported mechanisms follows")
+            output("STLS")
+            output("UIDL")
+            output("SASL PLAIN")
+            output(".")
+            expect("AUTH PLAIN")
+            output("+OK")
+            expect("AHVzZXIAcGFzc3dvcmQ=")
+            output("+OK")
+            expect("STAT")
+            output("+OK 2 320")
+            expect("QUIT")
+            closeConnection()
+        }
+        val serverSettings = ServerSettings(
+            type = "pop3",
+            host = server.host,
+            port = server.port,
+            connectionSecurity = ConnectionSecurity.NONE,
+            authenticationType = AuthType.PLAIN,
+            username = USERNAME,
+            password = PASSWORD,
+            clientCertificateAlias = CLIENT_CERTIFICATE_ALIAS,
+        )
+
+        val result = serverSettingsValidator.checkServerSettings(serverSettings, authStateStorage = null)
+
+        assertThat(result).isInstanceOf<ServerSettingsValidationResult.Success>()
+        server.verifyConnectionClosed()
+        server.verifyInteractionCompleted()
+    }
+
+    @Test
+    fun `authentication error should return AuthenticationError`() {
+        val server = startServer {
+            output("+OK POP3 server greeting")
+            expect("CAPA")
+            output("+OK Listing of supported mechanisms follows")
+            output("STLS")
+            output("UIDL")
+            output("SASL PLAIN")
+            output(".")
+            expect("AUTH PLAIN")
+            output("+OK")
+            expect("AHVzZXIAcGFzc3dvcmQ=")
+            output("-ERR Authentication failed")
+            expect("QUIT")
+            closeConnection()
+            closeConnection()
+        }
+        val serverSettings = ServerSettings(
+            type = "pop3",
+            host = server.host,
+            port = server.port,
+            connectionSecurity = ConnectionSecurity.NONE,
+            authenticationType = AuthType.PLAIN,
+            username = USERNAME,
+            password = PASSWORD,
+            clientCertificateAlias = CLIENT_CERTIFICATE_ALIAS,
+        )
+
+        val result = serverSettingsValidator.checkServerSettings(serverSettings, authStateStorage = null)
+
+        assertThat(result).isInstanceOf<ServerSettingsValidationResult.AuthenticationError>()
+            .prop(ServerSettingsValidationResult.AuthenticationError::serverMessage)
+            .isEqualTo("-ERR Authentication failed")
+        server.verifyConnectionClosed()
+        server.verifyInteractionCompleted()
+    }
+
+    @Test
+    fun `error code instead of greeting should return ServerError`() {
+        val server = startServer {
+            output("-ERR Service currently not available")
+            closeConnection()
+        }
+        val serverSettings = ServerSettings(
+            type = "pop3",
+            host = server.host,
+            port = server.port,
+            connectionSecurity = ConnectionSecurity.NONE,
+            authenticationType = AuthType.PLAIN,
+            username = USERNAME,
+            password = PASSWORD,
+            clientCertificateAlias = CLIENT_CERTIFICATE_ALIAS,
+        )
+
+        val result = serverSettingsValidator.checkServerSettings(serverSettings, authStateStorage = null)
+
+        assertThat(result).isInstanceOf<ServerSettingsValidationResult.ServerError>()
+            .prop(ServerSettingsValidationResult.ServerError::serverMessage)
+            .isEqualTo("-ERR Service currently not available")
+        server.verifyConnectionClosed()
+        server.verifyInteractionCompleted()
+    }
+
+    @Test
+    fun `certificate error when trying to connect should return CertificateError`() {
+        fakeTrustManager.shouldThrowException = true
+        val server = startServer {
+            output("+OK POP3 server greeting")
+            expect("CAPA")
+            output("+OK Listing of supported mechanisms follows")
+            output("STLS")
+            output("UIDL")
+            output("SASL PLAIN")
+            output(".")
+            expect("STLS")
+            output("+OK Begin TLS negotiation")
+            startTls()
+        }
+        val serverSettings = ServerSettings(
+            type = "pop3",
+            host = server.host,
+            port = server.port,
+            connectionSecurity = ConnectionSecurity.STARTTLS_REQUIRED,
+            authenticationType = AuthType.PLAIN,
+            username = USERNAME,
+            password = PASSWORD,
+            clientCertificateAlias = CLIENT_CERTIFICATE_ALIAS,
+        )
+
+        val result = serverSettingsValidator.checkServerSettings(serverSettings, authStateStorage = null)
+
+        assertThat(result).isInstanceOf<ServerSettingsValidationResult.CertificateError>()
+            .prop(ServerSettingsValidationResult.CertificateError::certificateChain).hasSize(1)
+        server.verifyConnectionClosed()
+        server.verifyInteractionCompleted()
+    }
+
+    @Test
+    fun `non-existent hostname should return NetworkError`() {
+        val serverSettings = ServerSettings(
+            type = "pop3",
+            host = "domain.invalid",
+            port = 587,
+            connectionSecurity = ConnectionSecurity.NONE,
+            authenticationType = AuthType.PLAIN,
+            username = USERNAME,
+            password = PASSWORD,
+            clientCertificateAlias = CLIENT_CERTIFICATE_ALIAS,
+        )
+
+        val result = serverSettingsValidator.checkServerSettings(serverSettings, authStateStorage = null)
+
+        assertThat(result).isInstanceOf<ServerSettingsValidationResult.NetworkError>()
+            .prop(ServerSettingsValidationResult.NetworkError::exception)
+            .isInstanceOf<UnknownHostException>()
+    }
+
+    @Test
+    fun `ServerSettings with wrong type should throw`() {
+        val serverSettings = ServerSettings(
+            type = "wrong",
+            host = "domain.invalid",
+            port = 587,
+            connectionSecurity = ConnectionSecurity.NONE,
+            authenticationType = AuthType.PLAIN,
+            username = USERNAME,
+            password = PASSWORD,
+            clientCertificateAlias = CLIENT_CERTIFICATE_ALIAS,
+        )
+
+        assertFailure {
+            serverSettingsValidator.checkServerSettings(serverSettings, authStateStorage = null)
+        }.isInstanceOf<IllegalArgumentException>()
+    }
+
+    private fun startServer(block: MockPop3Server.() -> Unit): MockPop3Server {
+        return MockPop3Server().apply {
+            block()
+            start()
+        }
+    }
+}
diff --git a/mail/protocols/smtp/src/main/java/com/fsck/k9/mail/transport/smtp/SmtpServerSettingsValidator.kt b/mail/protocols/smtp/src/main/java/com/fsck/k9/mail/transport/smtp/SmtpServerSettingsValidator.kt
new file mode 100644
index 0000000000000000000000000000000000000000..79d4f8c63381a58585be5331075a0d8f269e67ba
--- /dev/null
+++ b/mail/protocols/smtp/src/main/java/com/fsck/k9/mail/transport/smtp/SmtpServerSettingsValidator.kt
@@ -0,0 +1,57 @@
+package com.fsck.k9.mail.transport.smtp
+
+import com.fsck.k9.mail.AuthenticationFailedException
+import com.fsck.k9.mail.CertificateValidationException
+import com.fsck.k9.mail.MessagingException
+import com.fsck.k9.mail.ServerSettings
+import com.fsck.k9.mail.oauth.AuthStateStorage
+import com.fsck.k9.mail.oauth.OAuth2TokenProvider
+import com.fsck.k9.mail.oauth.OAuth2TokenProviderFactory
+import com.fsck.k9.mail.server.ServerSettingsValidationResult
+import com.fsck.k9.mail.server.ServerSettingsValidator
+import com.fsck.k9.mail.ssl.TrustedSocketFactory
+import java.io.IOException
+
+class SmtpServerSettingsValidator(
+    private val trustedSocketFactory: TrustedSocketFactory,
+    private val oAuth2TokenProviderFactory: OAuth2TokenProviderFactory?,
+) : ServerSettingsValidator {
+
+    @Suppress("TooGenericExceptionCaught")
+    override fun checkServerSettings(
+        serverSettings: ServerSettings,
+        authStateStorage: AuthStateStorage?,
+    ): ServerSettingsValidationResult {
+        val oAuth2TokenProvider = createOAuth2TokenProviderOrNull(authStateStorage)
+        val smtpTransport = SmtpTransport(serverSettings, trustedSocketFactory, oAuth2TokenProvider)
+
+        return try {
+            smtpTransport.checkSettings()
+
+            ServerSettingsValidationResult.Success
+        } catch (e: AuthenticationFailedException) {
+            ServerSettingsValidationResult.AuthenticationError(e.messageFromServer)
+        } catch (e: CertificateValidationException) {
+            ServerSettingsValidationResult.CertificateError(e.certChain.toList())
+        } catch (e: NegativeSmtpReplyException) {
+            ServerSettingsValidationResult.ServerError(e.replyText)
+        } catch (e: MessagingException) {
+            val cause = e.cause
+            if (cause is IOException) {
+                ServerSettingsValidationResult.NetworkError(cause)
+            } else {
+                ServerSettingsValidationResult.UnknownError(e)
+            }
+        } catch (e: IOException) {
+            ServerSettingsValidationResult.NetworkError(e)
+        } catch (e: Exception) {
+            ServerSettingsValidationResult.UnknownError(e)
+        }
+    }
+
+    private fun createOAuth2TokenProviderOrNull(authStateStorage: AuthStateStorage?): OAuth2TokenProvider? {
+        return authStateStorage?.let {
+            oAuth2TokenProviderFactory?.create(it)
+        }
+    }
+}
diff --git a/mail/protocols/smtp/src/main/java/com/fsck/k9/mail/transport/smtp/SmtpTransport.kt b/mail/protocols/smtp/src/main/java/com/fsck/k9/mail/transport/smtp/SmtpTransport.kt
index ea8fd318687b8c27212cddcd0339eec90cd71f0a..cd854267465d8304484557f1298d411469a693ae 100644
--- a/mail/protocols/smtp/src/main/java/com/fsck/k9/mail/transport/smtp/SmtpTransport.kt
+++ b/mail/protocols/smtp/src/main/java/com/fsck/k9/mail/transport/smtp/SmtpTransport.kt
@@ -281,6 +281,10 @@ class SmtpTransport(
     private fun readGreeting() {
         val smtpResponse = responseParser!!.readGreeting()
         logResponse(smtpResponse)
+
+        if (smtpResponse.isNegativeResponse) {
+            throw buildNegativeSmtpReplyException(smtpResponse)
+        }
     }
 
     private fun logResponse(smtpResponse: SmtpResponse, sensitive: Boolean = false) {
@@ -552,11 +556,7 @@ class SmtpTransport(
             executeSensitiveCommand(Base64.encode(username))
             executeSensitiveCommand(Base64.encode(password))
         } catch (exception: NegativeSmtpReplyException) {
-            if (exception.replyCode == SMTP_AUTHENTICATION_FAILURE_ERROR_CODE) {
-                throw AuthenticationFailedException("AUTH LOGIN failed (${exception.message})")
-            } else {
-                throw exception
-            }
+            handlePossibleAuthenticationFailure("AUTH LOGIN", exception)
         }
     }
 
@@ -565,11 +565,7 @@ class SmtpTransport(
         try {
             executeSensitiveCommand("AUTH PLAIN %s", data)
         } catch (exception: NegativeSmtpReplyException) {
-            if (exception.replyCode == SMTP_AUTHENTICATION_FAILURE_ERROR_CODE) {
-                throw AuthenticationFailedException("AUTH PLAIN failed (${exception.message})")
-            } else {
-                throw exception
-            }
+            handlePossibleAuthenticationFailure("AUTH PLAIN", exception)
         }
     }
 
@@ -584,11 +580,7 @@ class SmtpTransport(
         try {
             executeSensitiveCommand(b64CRAMString)
         } catch (exception: NegativeSmtpReplyException) {
-            if (exception.replyCode == SMTP_AUTHENTICATION_FAILURE_ERROR_CODE) {
-                throw AuthenticationFailedException(exception.message!!, exception)
-            } else {
-                throw exception
-            }
+            handlePossibleAuthenticationFailure("AUTH CRAM-MD5", exception)
         }
     }
 
@@ -604,18 +596,25 @@ class SmtpTransport(
             oauthTokenProvider!!.invalidateToken()
 
             if (!retryOAuthWithNewToken) {
-                handlePermanentFailure(negativeResponse)
+                handlePermanentOAuthFailure(method, negativeResponse)
             } else {
-                handleTemporaryFailure(method, username, negativeResponse)
+                handleTemporaryOAuthFailure(method, username, negativeResponse)
             }
         }
     }
 
-    private fun handlePermanentFailure(negativeResponse: NegativeSmtpReplyException): Nothing {
-        throw AuthenticationFailedException(negativeResponse.message!!, negativeResponse)
+    private fun handlePermanentOAuthFailure(
+        method: OAuthMethod,
+        negativeResponse: NegativeSmtpReplyException,
+    ): Nothing {
+        throw AuthenticationFailedException(
+            message = "${method.command} failed",
+            throwable = negativeResponse,
+            messageFromServer = negativeResponse.replyText,
+        )
     }
 
-    private fun handleTemporaryFailure(
+    private fun handleTemporaryOAuthFailure(
         method: OAuthMethod,
         username: String,
         negativeResponseFromOldToken: NegativeSmtpReplyException,
@@ -635,12 +634,12 @@ class SmtpTransport(
             Timber.v(negativeResponseFromNewToken, "Authentication exception for new token, permanent error assumed")
 
             oauthTokenProvider!!.invalidateToken()
-            handlePermanentFailure(negativeResponseFromNewToken)
+            handlePermanentOAuthFailure(method, negativeResponseFromNewToken)
         }
     }
 
     private fun attempOAuth(method: OAuthMethod, username: String) {
-        val token = oauthTokenProvider!!.getToken(username, OAuth2TokenProvider.OAUTH2_TIMEOUT.toLong())
+        val token = oauthTokenProvider!!.getToken(OAuth2TokenProvider.OAUTH2_TIMEOUT.toLong())
         val authString = method.buildInitialClientResponse(username, token)
 
         val response = executeSensitiveCommand("%s %s", method.command, authString)
@@ -657,6 +656,21 @@ class SmtpTransport(
         executeCommand("AUTH EXTERNAL %s", Base64.encode(username))
     }
 
+    private fun handlePossibleAuthenticationFailure(
+        authenticationMethod: String,
+        negativeResponse: NegativeSmtpReplyException,
+    ): Nothing {
+        if (negativeResponse.replyCode == SMTP_AUTHENTICATION_FAILURE_ERROR_CODE) {
+            throw AuthenticationFailedException(
+                message = "$authenticationMethod failed",
+                throwable = negativeResponse,
+                messageFromServer = negativeResponse.replyText,
+            )
+        } else {
+            throw negativeResponse
+        }
+    }
+
     @Throws(MessagingException::class)
     fun checkSettings() {
         ensureClosed()
diff --git a/mail/protocols/smtp/src/test/java/com/fsck/k9/mail/transport/smtp/SmtpResponseParserTest.kt b/mail/protocols/smtp/src/test/java/com/fsck/k9/mail/transport/smtp/SmtpResponseParserTest.kt
index 91c82341f6a2ce9d3885c976c66f1ac465622f13..b81d8172ee86615291a0abe147cb267b09d3e947 100644
--- a/mail/protocols/smtp/src/test/java/com/fsck/k9/mail/transport/smtp/SmtpResponseParserTest.kt
+++ b/mail/protocols/smtp/src/test/java/com/fsck/k9/mail/transport/smtp/SmtpResponseParserTest.kt
@@ -1,6 +1,7 @@
 package com.fsck.k9.mail.transport.smtp
 
 import assertk.all
+import assertk.assertFailure
 import assertk.assertThat
 import assertk.assertions.containsExactly
 import assertk.assertions.containsExactlyInAnyOrder
@@ -8,7 +9,6 @@ import assertk.assertions.hasMessage
 import assertk.assertions.hasSize
 import assertk.assertions.isEmpty
 import assertk.assertions.isEqualTo
-import assertk.assertions.isFailure
 import assertk.assertions.isFalse
 import assertk.assertions.isInstanceOf
 import assertk.assertions.isNotNull
@@ -69,7 +69,7 @@ class SmtpResponseParserTest {
 
         val response = parser.readHelloResponse()
 
-        assertThat(response).isInstanceOf(SmtpHelloResponse.Hello::class).all {
+        assertThat(response).isInstanceOf<SmtpHelloResponse.Hello>().all {
             prop(SmtpHelloResponse.Hello::response)
                 .transform { it.toLogString(false, "") }.isEqualTo(input)
             prop(SmtpHelloResponse.Hello::keywords).all {
@@ -98,7 +98,7 @@ class SmtpResponseParserTest {
 
         val response = parser.readHelloResponse()
 
-        assertThat(response).isInstanceOf(SmtpHelloResponse.Hello::class).all {
+        assertThat(response).isInstanceOf<SmtpHelloResponse.Hello>().all {
             prop(SmtpHelloResponse.Hello::response).all {
                 prop(SmtpResponse::replyCode).isEqualTo(250)
                 prop(SmtpResponse::texts).containsExactly("smtp.domain.example")
@@ -114,7 +114,7 @@ class SmtpResponseParserTest {
 
         val response = parser.readHelloResponse()
 
-        assertThat(response).isInstanceOf(SmtpHelloResponse.Error::class)
+        assertThat(response).isInstanceOf<SmtpHelloResponse.Error>()
             .prop(SmtpHelloResponse.Error::response).all {
                 prop(SmtpResponse::replyCode).isEqualTo(421)
                 prop(SmtpResponse::texts).containsExactly("Service not available")
@@ -126,10 +126,9 @@ class SmtpResponseParserTest {
         val input = "250".toPeekableInputStream()
         val parser = SmtpResponseParser(logger, input)
 
-        assertThat {
+        assertFailure {
             parser.readHelloResponse()
-        }.isFailure()
-            .isInstanceOf(SmtpResponseParserException::class)
+        }.isInstanceOf<SmtpResponseParserException>()
             .hasMessage("Unexpected character: (13)")
 
         assertThat(logger.logEntries).containsExactly(
@@ -151,10 +150,9 @@ class SmtpResponseParserTest {
         """.toPeekableInputStream()
         val parser = SmtpResponseParser(logger, input)
 
-        assertThat {
+        assertFailure {
             parser.readHelloResponse()
-        }.isFailure()
-            .isInstanceOf(SmtpResponseParserException::class)
+        }.isInstanceOf<SmtpResponseParserException>()
             .hasMessage("Multi-line response with reply codes not matching: 250 != 220")
 
         assertThat(logger.logEntries).containsExactly(
@@ -185,7 +183,7 @@ class SmtpResponseParserTest {
 
         val response = parser.readHelloResponse()
 
-        assertThat(response).isInstanceOf(SmtpHelloResponse.Hello::class)
+        assertThat(response).isInstanceOf<SmtpHelloResponse.Hello>()
             .prop(SmtpHelloResponse.Hello::keywords).transform { it.keys }.containsExactlyInAnyOrder(
                 "SIZE",
                 "8BITMIME",
@@ -215,7 +213,7 @@ class SmtpResponseParserTest {
 
         val response = parser.readHelloResponse()
 
-        assertThat(response).isInstanceOf(SmtpHelloResponse.Hello::class)
+        assertThat(response).isInstanceOf<SmtpHelloResponse.Hello>()
             .transform { it.keywords.keys }.isEmpty()
 
         assertThat(logger.logEntries).isNotNull().hasSize(1)
@@ -234,7 +232,7 @@ class SmtpResponseParserTest {
 
         val response = parser.readHelloResponse()
 
-        assertThat(response).isInstanceOf(SmtpHelloResponse.Hello::class)
+        assertThat(response).isInstanceOf<SmtpHelloResponse.Hello>()
             .transform { it.keywords.keys }.containsExactlyInAnyOrder("8BITMIME")
 
         assertThat(logger.logEntries).hasSize(1)
@@ -253,10 +251,9 @@ class SmtpResponseParserTest {
         val parser = SmtpResponseParser(logger, input)
         parser.readGreeting()
 
-        assertThat {
+        assertFailure {
             parser.readHelloResponse()
-        }.isFailure()
-            .isInstanceOf(SmtpResponseParserException::class)
+        }.isInstanceOf<SmtpResponseParserException>()
             .hasMessage("Unexpected character: I (73)")
 
         assertThat(logger.logEntries).containsExactly(
@@ -441,10 +438,9 @@ class SmtpResponseParserTest {
         """.toPeekableInputStream()
         val parser = SmtpResponseParser(logger, input)
 
-        assertThat {
+        assertFailure {
             parser.readResponse(enhancedStatusCodes = false)
-        }.isFailure()
-            .isInstanceOf(SmtpResponseParserException::class)
+        }.isInstanceOf<SmtpResponseParserException>()
             .hasMessage("Multi-line response with reply codes not matching: 200 != 500")
 
         assertThat(logger.logEntries).containsExactly(
@@ -468,10 +464,9 @@ class SmtpResponseParserTest {
         val logger = TestSmtpLogger(isRawProtocolLoggingEnabled = false)
         val parser = SmtpResponseParser(logger, input)
 
-        assertThat {
+        assertFailure {
             parser.readResponse(enhancedStatusCodes = false)
-        }.isFailure()
-            .isInstanceOf(SmtpResponseParserException::class)
+        }.isInstanceOf<SmtpResponseParserException>()
             .hasMessage("Multi-line response with reply codes not matching: 200 != 500")
         assertThat(logger.logEntries).isEmpty()
     }
@@ -481,10 +476,9 @@ class SmtpResponseParserTest {
         val input = "611".toPeekableInputStream()
         val parser = SmtpResponseParser(logger, input)
 
-        assertThat {
+        assertFailure {
             parser.readResponse(enhancedStatusCodes = false)
-        }.isFailure()
-            .isInstanceOf(SmtpResponseParserException::class)
+        }.isInstanceOf<SmtpResponseParserException>()
             .hasMessage("Unsupported 1st reply code digit: 6")
     }
 
@@ -508,10 +502,9 @@ class SmtpResponseParserTest {
         val input = "20x".toPeekableInputStream()
         val parser = SmtpResponseParser(logger, input)
 
-        assertThat {
+        assertFailure {
             parser.readResponse(enhancedStatusCodes = false)
-        }.isFailure()
-            .isInstanceOf(SmtpResponseParserException::class)
+        }.isInstanceOf<SmtpResponseParserException>()
             .hasMessage("Unexpected character: x (120)")
 
         assertThat(logger.logEntries).containsExactly(
@@ -530,10 +523,9 @@ class SmtpResponseParserTest {
         val input = PeekableInputStream("200".byteInputStream())
         val parser = SmtpResponseParser(logger, input)
 
-        assertThat {
+        assertFailure {
             parser.readResponse(enhancedStatusCodes = false)
-        }.isFailure()
-            .isInstanceOf(SmtpResponseParserException::class)
+        }.isInstanceOf<SmtpResponseParserException>()
             .hasMessage("Unexpected end of stream")
 
         assertThat(logger.logEntries).containsExactly(
@@ -552,10 +544,9 @@ class SmtpResponseParserTest {
         val input = PeekableInputStream("200\r".byteInputStream())
         val parser = SmtpResponseParser(logger, input)
 
-        assertThat {
+        assertFailure {
             parser.readResponse(enhancedStatusCodes = false)
-        }.isFailure()
-            .isInstanceOf(SmtpResponseParserException::class)
+        }.isInstanceOf<SmtpResponseParserException>()
             .hasMessage("Unexpected end of stream")
     }
 
@@ -564,10 +555,9 @@ class SmtpResponseParserTest {
         val input = PeekableInputStream("200\n".byteInputStream())
         val parser = SmtpResponseParser(logger, input)
 
-        assertThat {
+        assertFailure {
             parser.readResponse(enhancedStatusCodes = false)
-        }.isFailure()
-            .isInstanceOf(SmtpResponseParserException::class)
+        }.isInstanceOf<SmtpResponseParserException>()
             .hasMessage("Unexpected character: (10)")
 
         assertThat(logger.logEntries).containsExactly(
@@ -694,10 +684,9 @@ class SmtpResponseParserTest {
         """.toPeekableInputStream()
         val parser = SmtpResponseParser(logger, input)
 
-        assertThat {
+        assertFailure {
             parser.readResponse(enhancedStatusCodes = true)
-        }.isFailure()
-            .isInstanceOf(SmtpResponseParserException::class)
+        }.isInstanceOf<SmtpResponseParserException>()
             .hasMessage(
                 "Multi-line response with enhanced status codes not matching: " +
                     "EnhancedStatusCode(statusClass=PERMANENT_FAILURE, subject=2, detail=1) != null",
diff --git a/mail/protocols/smtp/src/test/java/com/fsck/k9/mail/transport/smtp/SmtpServerSettingsValidatorTest.kt b/mail/protocols/smtp/src/test/java/com/fsck/k9/mail/transport/smtp/SmtpServerSettingsValidatorTest.kt
new file mode 100644
index 0000000000000000000000000000000000000000..00e9588e0dda61c61178dcb9098e7a8c6bcfc0dc
--- /dev/null
+++ b/mail/protocols/smtp/src/test/java/com/fsck/k9/mail/transport/smtp/SmtpServerSettingsValidatorTest.kt
@@ -0,0 +1,264 @@
+package com.fsck.k9.mail.transport.smtp
+
+import assertk.assertFailure
+import assertk.assertThat
+import assertk.assertions.hasSize
+import assertk.assertions.isEqualTo
+import assertk.assertions.isInstanceOf
+import assertk.assertions.prop
+import com.fsck.k9.mail.AuthType
+import com.fsck.k9.mail.ConnectionSecurity
+import com.fsck.k9.mail.ServerSettings
+import com.fsck.k9.mail.helpers.FakeTrustManager
+import com.fsck.k9.mail.helpers.SimpleTrustedSocketFactory
+import com.fsck.k9.mail.oauth.AuthStateStorage
+import com.fsck.k9.mail.oauth.OAuth2TokenProvider
+import com.fsck.k9.mail.server.ServerSettingsValidationResult
+import com.fsck.k9.mail.transport.mockServer.MockSmtpServer
+import java.net.UnknownHostException
+import kotlin.test.Test
+
+private const val USERNAME = "user"
+private const val PASSWORD = "password"
+private const val AUTHORIZATION_STATE = "auth state"
+private const val AUTHORIZATION_TOKEN = "auth-token"
+private val CLIENT_CERTIFICATE_ALIAS: String? = null
+
+class SmtpServerSettingsValidatorTest {
+    private val fakeTrustManager = FakeTrustManager()
+    private val trustedSocketFactory = SimpleTrustedSocketFactory(fakeTrustManager)
+    private val serverSettingsValidator = SmtpServerSettingsValidator(
+        trustedSocketFactory = trustedSocketFactory,
+        oAuth2TokenProviderFactory = null,
+    )
+
+    @Test
+    fun `valid server settings with password should return Success`() {
+        val server = MockSmtpServer().apply {
+            output("220 localhost Simple Mail Transfer Service Ready")
+            expect("EHLO [127.0.0.1]")
+            output("250-localhost Hello client.localhost")
+            output("250-ENHANCEDSTATUSCODES")
+            output("250-AUTH PLAIN LOGIN")
+            output("250 HELP")
+            expect("AUTH PLAIN AHVzZXIAcGFzc3dvcmQ=")
+            output("235 2.7.0 Authentication successful")
+            expect("QUIT")
+            closeConnection()
+        }
+        server.start()
+        val serverSettings = ServerSettings(
+            type = "smtp",
+            host = server.host,
+            port = server.port,
+            connectionSecurity = ConnectionSecurity.NONE,
+            authenticationType = AuthType.PLAIN,
+            username = USERNAME,
+            password = PASSWORD,
+            clientCertificateAlias = CLIENT_CERTIFICATE_ALIAS,
+        )
+
+        val result = serverSettingsValidator.checkServerSettings(serverSettings, authStateStorage = null)
+
+        assertThat(result).isInstanceOf<ServerSettingsValidationResult.Success>()
+        server.verifyConnectionClosed()
+        server.verifyInteractionCompleted()
+    }
+
+    @Test
+    fun `valid server settings with OAuth should return Success`() {
+        val serverSettingsValidator = SmtpServerSettingsValidator(
+            trustedSocketFactory = trustedSocketFactory,
+            oAuth2TokenProviderFactory = { authStateStorage ->
+                assertThat(authStateStorage.getAuthorizationState()).isEqualTo(AUTHORIZATION_STATE)
+                FakeOAuth2TokenProvider()
+            },
+        )
+        val server = MockSmtpServer().apply {
+            output("220 localhost Simple Mail Transfer Service Ready")
+            expect("EHLO [127.0.0.1]")
+            output("250-localhost Hello client.localhost")
+            output("250-ENHANCEDSTATUSCODES")
+            output("250-AUTH PLAIN LOGIN OAUTHBEARER")
+            output("250 HELP")
+            expect("AUTH OAUTHBEARER bixhPXVzZXIsAWF1dGg9QmVhcmVyIGF1dGgtdG9rZW4BAQ==")
+            output("235 2.7.0 Authentication successful")
+            expect("QUIT")
+            closeConnection()
+        }
+        server.start()
+        val serverSettings = ServerSettings(
+            type = "smtp",
+            host = server.host,
+            port = server.port,
+            connectionSecurity = ConnectionSecurity.NONE,
+            authenticationType = AuthType.XOAUTH2,
+            username = USERNAME,
+            password = null,
+            clientCertificateAlias = CLIENT_CERTIFICATE_ALIAS,
+        )
+        val authStateStorage = FakeAuthStateStorage(authorizationState = AUTHORIZATION_STATE)
+
+        val result = serverSettingsValidator.checkServerSettings(serverSettings, authStateStorage)
+
+        assertThat(result).isInstanceOf<ServerSettingsValidationResult.Success>()
+        server.verifyConnectionClosed()
+        server.verifyInteractionCompleted()
+    }
+
+    @Test
+    fun `authentication error should return AuthenticationError`() {
+        val server = MockSmtpServer().apply {
+            output("220 localhost Simple Mail Transfer Service Ready")
+            expect("EHLO [127.0.0.1]")
+            output("250-localhost Hello client.localhost")
+            output("250-ENHANCEDSTATUSCODES")
+            output("250-AUTH PLAIN LOGIN")
+            output("250 HELP")
+            expect("AUTH PLAIN AHVzZXIAcGFzc3dvcmQ=")
+            output("535 5.7.8 Authentication failed")
+            expect("QUIT")
+            closeConnection()
+        }
+        server.start()
+        val serverSettings = ServerSettings(
+            type = "smtp",
+            host = server.host,
+            port = server.port,
+            connectionSecurity = ConnectionSecurity.NONE,
+            authenticationType = AuthType.PLAIN,
+            username = USERNAME,
+            password = PASSWORD,
+            clientCertificateAlias = CLIENT_CERTIFICATE_ALIAS,
+        )
+
+        val result = serverSettingsValidator.checkServerSettings(serverSettings, authStateStorage = null)
+
+        assertThat(result).isInstanceOf<ServerSettingsValidationResult.AuthenticationError>()
+            .prop(ServerSettingsValidationResult.AuthenticationError::serverMessage).isEqualTo("Authentication failed")
+        server.verifyConnectionClosed()
+        server.verifyInteractionCompleted()
+    }
+
+    @Test
+    fun `error code instead of greeting should return ServerError`() {
+        val server = MockSmtpServer().apply {
+            output("421 domain.example Service currently not available")
+            closeConnection()
+        }
+        server.start()
+        val serverSettings = ServerSettings(
+            type = "smtp",
+            host = server.host,
+            port = server.port,
+            connectionSecurity = ConnectionSecurity.NONE,
+            authenticationType = AuthType.PLAIN,
+            username = USERNAME,
+            password = PASSWORD,
+            clientCertificateAlias = CLIENT_CERTIFICATE_ALIAS,
+        )
+
+        val result = serverSettingsValidator.checkServerSettings(serverSettings, authStateStorage = null)
+
+        assertThat(result).isInstanceOf<ServerSettingsValidationResult.ServerError>()
+        server.verifyConnectionClosed()
+        server.verifyInteractionCompleted()
+    }
+
+    @Test
+    fun `certificate error when trying to connect should return CertificateError`() {
+        fakeTrustManager.shouldThrowException = true
+        val server = MockSmtpServer().apply {
+            output("220 localhost Simple Mail Transfer Service Ready")
+            expect("EHLO [127.0.0.1]")
+            output("250-localhost Hello 127.0.0.1")
+            output("250-STARTTLS")
+            output("250 HELP")
+            expect("STARTTLS")
+            output("220 Ready to start TLS")
+            startTls()
+        }
+        server.start()
+        val serverSettings = ServerSettings(
+            type = "smtp",
+            host = server.host,
+            port = server.port,
+            connectionSecurity = ConnectionSecurity.STARTTLS_REQUIRED,
+            authenticationType = AuthType.PLAIN,
+            username = USERNAME,
+            password = PASSWORD,
+            clientCertificateAlias = CLIENT_CERTIFICATE_ALIAS,
+        )
+
+        val result = serverSettingsValidator.checkServerSettings(serverSettings, authStateStorage = null)
+
+        assertThat(result).isInstanceOf<ServerSettingsValidationResult.CertificateError>()
+            .prop(ServerSettingsValidationResult.CertificateError::certificateChain).hasSize(1)
+        server.verifyConnectionClosed()
+        server.verifyInteractionCompleted()
+    }
+
+    @Test
+    fun `non-existent hostname should return NetworkError`() {
+        val serverSettings = ServerSettings(
+            type = "smtp",
+            host = "domain.invalid",
+            port = 587,
+            connectionSecurity = ConnectionSecurity.NONE,
+            authenticationType = AuthType.PLAIN,
+            username = USERNAME,
+            password = PASSWORD,
+            clientCertificateAlias = CLIENT_CERTIFICATE_ALIAS,
+        )
+
+        val result = serverSettingsValidator.checkServerSettings(serverSettings, authStateStorage = null)
+
+        assertThat(result).isInstanceOf<ServerSettingsValidationResult.NetworkError>()
+            .prop(ServerSettingsValidationResult.NetworkError::exception)
+            .isInstanceOf<UnknownHostException>()
+    }
+
+    @Test
+    fun `ServerSettings with wrong type should throw`() {
+        val serverSettings = ServerSettings(
+            type = "wrong",
+            host = "domain.invalid",
+            port = 587,
+            connectionSecurity = ConnectionSecurity.NONE,
+            authenticationType = AuthType.PLAIN,
+            username = USERNAME,
+            password = PASSWORD,
+            clientCertificateAlias = CLIENT_CERTIFICATE_ALIAS,
+        )
+
+        assertFailure {
+            serverSettingsValidator.checkServerSettings(serverSettings, authStateStorage = null)
+        }.isInstanceOf<IllegalArgumentException>()
+    }
+}
+
+class FakeOAuth2TokenProvider : OAuth2TokenProvider {
+    override fun getToken(timeoutMillis: Long): String {
+        return AUTHORIZATION_TOKEN
+    }
+
+    override fun invalidateToken() {
+        throw UnsupportedOperationException("not implemented")
+    }
+}
+
+class FakeAuthStateStorage(
+    private var authorizationState: String? = null,
+) : AuthStateStorage {
+    override fun getAuthorizationState(): String? {
+        return authorizationState
+    }
+
+    override fun updateAuthorizationState(authorizationState: String?) {
+        this.authorizationState = authorizationState
+    }
+
+    override fun getEmail(): String? {
+        return null
+    }
+}
diff --git a/mail/protocols/smtp/src/test/java/com/fsck/k9/mail/transport/smtp/SmtpTransportTest.kt b/mail/protocols/smtp/src/test/java/com/fsck/k9/mail/transport/smtp/SmtpTransportTest.kt
index 1e5832fac8e0c9df3112bdabd14a3241012d6b0e..1191799154e4ad8dd930596b4967e6f88789b248 100644
--- a/mail/protocols/smtp/src/test/java/com/fsck/k9/mail/transport/smtp/SmtpTransportTest.kt
+++ b/mail/protocols/smtp/src/test/java/com/fsck/k9/mail/transport/smtp/SmtpTransportTest.kt
@@ -1,10 +1,10 @@
 package com.fsck.k9.mail.transport.smtp
 
+import assertk.Assert
 import assertk.all
-import assertk.assertThat
+import assertk.assertFailure
 import assertk.assertions.hasMessage
 import assertk.assertions.isEqualTo
-import assertk.assertions.isFailure
 import assertk.assertions.isInstanceOf
 import assertk.assertions.isTrue
 import assertk.assertions.prop
@@ -124,10 +124,9 @@ class SmtpTransportTest {
         }
         val transport = startServerAndCreateSmtpTransport(server, authenticationType = AuthType.PLAIN)
 
-        assertThat {
+        assertFailure {
             transport.open()
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("Authentication methods SASL PLAIN and LOGIN are unavailable.")
 
         server.verifyConnectionClosed()
@@ -166,10 +165,9 @@ class SmtpTransportTest {
         }
         val transport = startServerAndCreateSmtpTransport(server, authenticationType = AuthType.CRAM_MD5)
 
-        assertThat {
+        assertFailure {
             transport.open()
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("Authentication method CRAM-MD5 is unavailable.")
 
         server.verifyConnectionClosed()
@@ -236,6 +234,7 @@ class SmtpTransportTest {
             output("220 localhost Simple Mail Transfer Service Ready")
             expect("EHLO [127.0.0.1]")
             output("250-localhost Hello client.localhost")
+            output("250-ENHANCEDSTATUSCODES")
             output("250 AUTH XOAUTH2")
             expect("AUTH XOAUTH2 dXNlcj11c2VyAWF1dGg9QmVhcmVyIG9sZFRva2VuAQE=")
             output("334 " + XOAuth2ChallengeParserTest.STATUS_401_RESPONSE)
@@ -247,17 +246,16 @@ class SmtpTransportTest {
         }
         val transport = startServerAndCreateSmtpTransport(server, authenticationType = AuthType.XOAUTH2)
 
-        assertThat {
+        assertFailure {
             transport.open()
-        }.isFailure()
-            .isInstanceOf(AuthenticationFailedException::class)
-            .hasMessage(
-                "5.7.1 Username and Password not accepted. Learn more at " +
-                    "5.7.1 http://support.google.com/mail/bin/answer.py?answer=14257 hx9sm5317360pbc.68",
+        }.isInstanceOf<AuthenticationFailedException>()
+            .hasServerMessage(
+                "Username and Password not accepted. Learn more at " +
+                    "http://support.google.com/mail/bin/answer.py?answer=14257 hx9sm5317360pbc.68",
             )
 
         inOrder(oAuth2TokenProvider) {
-            verify(oAuth2TokenProvider).getToken(anyString(), anyLong())
+            verify(oAuth2TokenProvider).getToken(anyLong())
             verify(oAuth2TokenProvider).invalidateToken()
         }
         server.verifyConnectionClosed()
@@ -284,9 +282,9 @@ class SmtpTransportTest {
         transport.open()
 
         inOrder(oAuth2TokenProvider) {
-            verify(oAuth2TokenProvider).getToken(anyString(), anyLong())
+            verify(oAuth2TokenProvider).getToken(anyLong())
             verify(oAuth2TokenProvider).invalidateToken()
-            verify(oAuth2TokenProvider).getToken(anyString(), anyLong())
+            verify(oAuth2TokenProvider).getToken(anyLong())
         }
         server.verifyConnectionStillOpen()
         server.verifyInteractionCompleted()
@@ -312,9 +310,9 @@ class SmtpTransportTest {
         transport.open()
 
         inOrder(oAuth2TokenProvider) {
-            verify(oAuth2TokenProvider).getToken(anyString(), anyLong())
+            verify(oAuth2TokenProvider).getToken(anyLong())
             verify(oAuth2TokenProvider).invalidateToken()
-            verify(oAuth2TokenProvider).getToken(anyString(), anyLong())
+            verify(oAuth2TokenProvider).getToken(anyLong())
         }
         server.verifyConnectionStillOpen()
         server.verifyInteractionCompleted()
@@ -340,9 +338,9 @@ class SmtpTransportTest {
         transport.open()
 
         inOrder(oAuth2TokenProvider) {
-            verify(oAuth2TokenProvider).getToken(anyString(), anyLong())
+            verify(oAuth2TokenProvider).getToken(anyLong())
             verify(oAuth2TokenProvider).invalidateToken()
-            verify(oAuth2TokenProvider).getToken(anyString(), anyLong())
+            verify(oAuth2TokenProvider).getToken(anyLong())
         }
         server.verifyConnectionStillOpen()
         server.verifyInteractionCompleted()
@@ -354,6 +352,7 @@ class SmtpTransportTest {
             output("220 localhost Simple Mail Transfer Service Ready")
             expect("EHLO [127.0.0.1]")
             output("250-localhost Hello client.localhost")
+            output("250-ENHANCEDSTATUSCODES")
             output("250 AUTH XOAUTH2")
             expect("AUTH XOAUTH2 dXNlcj11c2VyAWF1dGg9QmVhcmVyIG9sZFRva2VuAQE=")
             output("334 " + XOAuth2ChallengeParserTest.STATUS_400_RESPONSE)
@@ -371,13 +370,12 @@ class SmtpTransportTest {
 
         val transport = startServerAndCreateSmtpTransport(server, authenticationType = AuthType.XOAUTH2)
 
-        assertThat {
+        assertFailure {
             transport.open()
-        }.isFailure()
-            .isInstanceOf(AuthenticationFailedException::class)
-            .hasMessage(
-                "5.7.1 Username and Password not accepted. Learn more at " +
-                    "5.7.1 http://support.google.com/mail/bin/answer.py?answer=14257 hx9sm5317360pbc.68",
+        }.isInstanceOf<AuthenticationFailedException>()
+            .hasServerMessage(
+                "Username and Password not accepted. Learn more at " +
+                    "http://support.google.com/mail/bin/answer.py?answer=14257 hx9sm5317360pbc.68",
             )
 
         server.verifyConnectionClosed()
@@ -395,14 +393,13 @@ class SmtpTransportTest {
             output("221 BYE")
         }
         stubbing(oAuth2TokenProvider) {
-            on { getToken(anyString(), anyLong()) } doThrow AuthenticationFailedException("Failed to fetch token")
+            on { getToken(anyLong()) } doThrow AuthenticationFailedException("Failed to fetch token")
         }
         val transport = startServerAndCreateSmtpTransport(server, authenticationType = AuthType.XOAUTH2)
 
-        assertThat {
+        assertFailure {
             transport.open()
-        }.isFailure()
-            .isInstanceOf(AuthenticationFailedException::class)
+        }.isInstanceOf<AuthenticationFailedException>()
             .hasMessage("Failed to fetch token")
 
         server.verifyConnectionClosed()
@@ -421,10 +418,9 @@ class SmtpTransportTest {
         }
         val transport = startServerAndCreateSmtpTransport(server, authenticationType = AuthType.XOAUTH2)
 
-        assertThat {
+        assertFailure {
             transport.open()
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("Server doesn't support SASL OAUTHBEARER or XOAUTH2.")
 
         server.verifyConnectionClosed()
@@ -461,10 +457,9 @@ class SmtpTransportTest {
         }
         val transport = startServerAndCreateSmtpTransport(server, authenticationType = AuthType.EXTERNAL)
 
-        assertThat {
+        assertFailure {
             transport.open()
-        }.isFailure()
-            .isInstanceOf(CertificateValidationException::class)
+        }.isInstanceOf<CertificateValidationException>()
             .prop(CertificateValidationException::getReason)
             .isEqualTo(CertificateValidationException.Reason.MissingCapability)
 
@@ -511,10 +506,9 @@ class SmtpTransportTest {
             connectionSecurity = ConnectionSecurity.NONE,
         )
 
-        assertThat {
+        assertFailure {
             transport.open()
-        }.isFailure()
-            .isInstanceOf(MessagingException::class)
+        }.isInstanceOf<MessagingException>()
             .hasMessage("Update your outgoing server authentication setting. AUTOMATIC authentication is unavailable.")
 
         server.verifyConnectionClosed()
@@ -555,17 +549,16 @@ class SmtpTransportTest {
         server.output("221 BYE")
         val transport = startServerAndCreateSmtpTransport(server, authenticationType = AuthType.XOAUTH2)
 
-        assertThat {
+        assertFailure {
             transport.open()
-        }.isFailure()
-            .isInstanceOf(AuthenticationFailedException::class)
-            .hasMessage(
+        }.isInstanceOf<AuthenticationFailedException>()
+            .hasServerMessage(
                 "Username and Password not accepted. " +
                     "Learn more at http://support.google.com/mail/bin/answer.py?answer=14257 hx9sm5317360pbc.68",
             )
 
         inOrder(oAuth2TokenProvider) {
-            verify(oAuth2TokenProvider).getToken(anyString(), anyLong())
+            verify(oAuth2TokenProvider).getToken(anyLong())
             verify(oAuth2TokenProvider).invalidateToken()
         }
         server.verifyConnectionClosed()
@@ -720,13 +713,12 @@ class SmtpTransportTest {
         val server = createServerAndSetupForPlainAuthentication("SIZE 1000")
         val transport = startServerAndCreateSmtpTransport(server)
 
-        assertThat {
+        assertFailure {
             transport.sendMessage(message)
-        }.isFailure()
-            .isInstanceOf(MessagingException::class).all {
-                hasMessage("Message too large for server")
-                transform { it.isPermanentFailure }.isTrue()
-            }
+        }.isInstanceOf<MessagingException>().all {
+            hasMessage("Message too large for server")
+            transform { it.isPermanentFailure }.isTrue()
+        }
 
         // FIXME: Make sure connection was closed
         // server.verifyConnectionClosed();
@@ -751,13 +743,12 @@ class SmtpTransportTest {
         }
         val transport = startServerAndCreateSmtpTransport(server)
 
-        assertThat {
+        assertFailure {
             transport.sendMessage(message)
-        }.isFailure()
-            .isInstanceOf(NegativeSmtpReplyException::class).all {
-                prop(NegativeSmtpReplyException::replyCode).isEqualTo(421)
-                prop(NegativeSmtpReplyException::replyText).isEqualTo("4.7.0 Temporary system problem")
-            }
+        }.isInstanceOf<NegativeSmtpReplyException>().all {
+            prop(NegativeSmtpReplyException::replyCode).isEqualTo(421)
+            prop(NegativeSmtpReplyException::replyText).isEqualTo("4.7.0 Temporary system problem")
+        }
 
         server.verifyConnectionClosed()
         server.verifyInteractionCompleted()
@@ -827,14 +818,13 @@ class SmtpTransportTest {
         }
         val transport = startServerAndCreateSmtpTransport(server)
 
-        assertThat {
+        assertFailure {
             transport.sendMessage(message)
-        }.isFailure()
-            .isInstanceOf(NegativeSmtpReplyException::class).all {
-                prop(NegativeSmtpReplyException::replyCode).isEqualTo(550)
-                prop(NegativeSmtpReplyException::replyText)
-                    .isEqualTo("remote mail to <user2@localhost> not allowed")
-            }
+        }.isInstanceOf<NegativeSmtpReplyException>().all {
+            prop(NegativeSmtpReplyException::replyCode).isEqualTo(550)
+            prop(NegativeSmtpReplyException::replyText)
+                .isEqualTo("remote mail to <user2@localhost> not allowed")
+        }
 
         server.verifyConnectionClosed()
         server.verifyInteractionCompleted()
@@ -853,14 +843,13 @@ class SmtpTransportTest {
         server.closeConnection()
         val transport = startServerAndCreateSmtpTransport(server)
 
-        assertThat {
+        assertFailure {
             transport.sendMessage(message)
-        }.isFailure()
-            .isInstanceOf(NegativeSmtpReplyException::class).all {
-                prop(NegativeSmtpReplyException::replyCode).isEqualTo(550)
-                prop(NegativeSmtpReplyException::replyText)
-                    .isEqualTo("remote mail to <user2@localhost> not allowed")
-            }
+        }.isInstanceOf<NegativeSmtpReplyException>().all {
+            prop(NegativeSmtpReplyException::replyCode).isEqualTo(550)
+            prop(NegativeSmtpReplyException::replyText)
+                .isEqualTo("remote mail to <user2@localhost> not allowed")
+        }
 
         server.verifyConnectionClosed()
         server.verifyInteractionCompleted()
@@ -882,14 +871,13 @@ class SmtpTransportTest {
         }
         val transport = startServerAndCreateSmtpTransport(server)
 
-        assertThat {
+        assertFailure {
             transport.sendMessage(message)
-        }.isFailure()
-            .isInstanceOf(NegativeSmtpReplyException::class).all {
-                prop(NegativeSmtpReplyException::replyCode).isEqualTo(550)
-                prop(NegativeSmtpReplyException::replyText)
-                    .isEqualTo("remote mail to <user2@localhost> not allowed")
-            }
+        }.isInstanceOf<NegativeSmtpReplyException>().all {
+            prop(NegativeSmtpReplyException::replyCode).isEqualTo(550)
+            prop(NegativeSmtpReplyException::replyText)
+                .isEqualTo("remote mail to <user2@localhost> not allowed")
+        }
 
         server.verifyConnectionClosed()
         server.verifyInteractionCompleted()
@@ -911,14 +899,13 @@ class SmtpTransportTest {
         }
         val transport = startServerAndCreateSmtpTransport(server)
 
-        assertThat {
+        assertFailure {
             transport.sendMessage(message)
-        }.isFailure()
-            .isInstanceOf(NegativeSmtpReplyException::class).all {
-                prop(NegativeSmtpReplyException::replyCode).isEqualTo(550)
-                prop(NegativeSmtpReplyException::replyText)
-                    .isEqualTo("remote mail to <user3@localhost> not allowed")
-            }
+        }.isInstanceOf<NegativeSmtpReplyException>().all {
+            prop(NegativeSmtpReplyException::replyCode).isEqualTo(550)
+            prop(NegativeSmtpReplyException::replyText)
+                .isEqualTo("remote mail to <user3@localhost> not allowed")
+        }
 
         server.verifyConnectionClosed()
         server.verifyInteractionCompleted()
@@ -986,7 +973,11 @@ class SmtpTransportTest {
 
     private fun createMockOAuth2TokenProvider(): OAuth2TokenProvider {
         return mock {
-            on { getToken(anyString(), anyLong()) } doReturn "oldToken" doReturn "newToken"
+            on { getToken(anyLong()) } doReturn "oldToken" doReturn "newToken"
         }
     }
 }
+
+private fun Assert<AuthenticationFailedException>.hasServerMessage(expected: String) = given { actual ->
+    assertThat(actual.messageFromServer).isEqualTo(expected)
+}
diff --git a/mail/testing/build.gradle.kts b/mail/testing/build.gradle.kts
index a5253fd9cfdeb1dc58aa71de2b3a47882c9fb294..38ff9537928898f5b6ef6270e44dd307e8794d1d 100644
--- a/mail/testing/build.gradle.kts
+++ b/mail/testing/build.gradle.kts
@@ -13,4 +13,5 @@ dependencies {
 
     api(libs.okio)
     api(libs.junit)
+    api(libs.assertk)
 }
diff --git a/mail/testing/src/main/java/com/fsck/k9/mail/assertk/MessageExtensions.kt b/mail/testing/src/main/java/com/fsck/k9/mail/assertk/MessageExtensions.kt
new file mode 100644
index 0000000000000000000000000000000000000000..42cfd968a4ffe2631146a9d68cc143c692b815c7
--- /dev/null
+++ b/mail/testing/src/main/java/com/fsck/k9/mail/assertk/MessageExtensions.kt
@@ -0,0 +1,41 @@
+@file:Suppress("TooManyFunctions")
+
+package com.fsck.k9.mail.assertk
+
+import assertk.Assert
+import assertk.assertions.prop
+import com.fsck.k9.mail.Body
+import com.fsck.k9.mail.BodyPart
+import com.fsck.k9.mail.Part
+import com.fsck.k9.mail.internet.MimeMultipart
+import com.fsck.k9.mail.internet.MimeParameterDecoder
+import com.fsck.k9.mail.internet.MimeUtility
+import com.fsck.k9.mail.internet.MimeValue
+import com.fsck.k9.mail.internet.RawDataBody
+import com.fsck.k9.mail.internet.TextBody
+
+fun Assert<Part>.body() = prop(Part::getBody)
+
+@JvmName("textBodyEncoding")
+fun Assert<TextBody>.contentTransferEncoding() = prop(TextBody::getEncoding)
+
+@JvmName("rawDataBodyEncoding")
+fun Assert<RawDataBody>.contentTransferEncoding() = prop(RawDataBody::getEncoding)
+
+fun Assert<Body>.asBytes() = transform { it.inputStream.readBytes() }
+
+fun Assert<Body>.asText() = transform {
+    String(MimeUtility.decodeBody(it).readBytes())
+}
+
+fun Assert<MimeMultipart>.bodyParts() = transform { it.bodyParts }
+
+fun Assert<MimeMultipart>.bodyPart(index: Int): Assert<BodyPart> = transform { it.getBodyPart(index) }
+
+fun Assert<Part>.mimeType() = transform { it.mimeType }
+
+fun Assert<Part>.contentType() = transform { MimeParameterDecoder.decode(it.contentType) }
+
+fun Assert<MimeValue>.value() = transform { it.value }
+
+fun Assert<MimeValue>.parameter(name: String): Assert<String?> = transform { it.parameters[name] }
diff --git a/mail/testing/src/main/java/com/fsck/k9/mail/helpers/FakeTrustManager.kt b/mail/testing/src/main/java/com/fsck/k9/mail/helpers/FakeTrustManager.kt
new file mode 100644
index 0000000000000000000000000000000000000000..c03cfe0604379ba3b476114e579781acda57addc
--- /dev/null
+++ b/mail/testing/src/main/java/com/fsck/k9/mail/helpers/FakeTrustManager.kt
@@ -0,0 +1,20 @@
+package com.fsck.k9.mail.helpers
+
+import com.fsck.k9.mail.CertificateChainException
+import java.security.cert.X509Certificate
+import javax.net.ssl.X509TrustManager
+
+@Suppress("CustomX509TrustManager")
+class FakeTrustManager : X509TrustManager {
+    var shouldThrowException = false
+
+    override fun checkClientTrusted(chain: Array<out X509Certificate>?, authType: String?) = Unit
+
+    override fun checkServerTrusted(chain: Array<out X509Certificate>?, authType: String?) {
+        if (shouldThrowException) {
+            throw CertificateChainException("Test", chain, Exception("cause"))
+        }
+    }
+
+    override fun getAcceptedIssuers(): Array<X509Certificate> = emptyArray()
+}
diff --git a/mail/testing/src/main/java/com/fsck/k9/mail/helpers/SimpleTrustedSocketFactory.kt b/mail/testing/src/main/java/com/fsck/k9/mail/helpers/SimpleTrustedSocketFactory.kt
new file mode 100644
index 0000000000000000000000000000000000000000..74ba8d8108f9c70c4377cdc9d0159c9a8c7e34af
--- /dev/null
+++ b/mail/testing/src/main/java/com/fsck/k9/mail/helpers/SimpleTrustedSocketFactory.kt
@@ -0,0 +1,26 @@
+package com.fsck.k9.mail.helpers
+
+import com.fsck.k9.mail.ssl.TrustedSocketFactory
+import java.net.Socket
+import javax.net.ssl.SSLContext
+import javax.net.ssl.TrustManager
+import javax.net.ssl.X509TrustManager
+
+class SimpleTrustedSocketFactory(private val trustManager: X509TrustManager) : TrustedSocketFactory {
+    override fun createSocket(socket: Socket?, host: String, port: Int, clientCertificateAlias: String?): Socket {
+        requireNotNull(socket)
+
+        val trustManagers = arrayOf<TrustManager>(trustManager)
+
+        val sslContext = SSLContext.getInstance("TLS").apply {
+            init(null, trustManagers, null)
+        }
+
+        return sslContext.socketFactory.createSocket(
+            socket,
+            socket.inetAddress.hostAddress,
+            socket.port,
+            true,
+        )
+    }
+}
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 8606d7c6febeea50ff39b380afb32d28c1847cf7..25d249ad6b1dcb400fb97d480e4a885329f3aa38 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -40,18 +40,24 @@ include(
 )
 
 include(
+    ":feature:launcher",
+    ":feature:account:common",
     ":feature:account:setup",
+    ":feature:account:oauth",
     ":feature:onboarding",
     ":feature:autodiscovery:api",
     ":feature:autodiscovery:providersxml",
     ":feature:autodiscovery:srvrecords",
     ":feature:autodiscovery:autoconfig",
+    ":feature:autodiscovery:service",
 )
 
 include(
     ":core:common",
+    ":core:featureflags",
     ":core:testing",
     ":core:android:common",
+    ":core:android:testing",
     ":core:ui:compose:common",
     ":core:ui:compose:designsystem",
     ":core:ui:compose:theme",
@@ -83,4 +89,7 @@ include(
 
 include(":plugins:openpgp-api-lib:openpgp-api")
 
-include(":cli:html-cleaner-cli")
+include(
+    ":cli:autodiscovery-cli",
+    ":cli:html-cleaner-cli",
+)