openuispec 0.1.18 → 0.1.20

package/examples/todo-orbit/generated/android/Todo Orbit/app/src/main/java/uz/rsteam/todoorbit/support/Models.kt

@@ -0,0 +1,169 @@
+package uz.rsteam.todoorbit
+
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.saveable.Saver
+import androidx.compose.runtime.saveable.listSaver
+import androidx.compose.ui.res.stringResource
+import java.time.LocalDate
+import java.time.LocalDateTime
+
+enum class ScreenTab { Tasks, Analytics, Settings }
+
+enum class UiLocale { En, Ru }
+
+enum class ThemeMode { Light, Dark }
+
+enum class TaskStatus { Open, Done }
+
+enum class Priority { Low, Medium, High }
+
+enum class TaskFilter { All, Open, Done }
+
+enum class AnalyticsPeriod { Week, Month, Quarter }
+
+enum class Cadence { Daily, Weekly, Monthly }
+
+enum class Weekday { Mon, Tue, Wed, Thu, Fri, Sat, Sun }
+
+enum class SummaryChannel { Push, Email }
+
+enum class PreviewMode { Invalid, Empty, Ready }
+
+sealed interface OverlayState {
+    data object CreateTask : OverlayState
+    data class EditTask(val taskId: String) : OverlayState
+    data object RecurringRule : OverlayState
+    data class TaskMeta(val taskId: String) : OverlayState
+}
+
+data class PreferencesState(
+    val locale: UiLocale = UiLocale.En,
+    val themeMode: ThemeMode = ThemeMode.Light,
+    val remindersEnabled: Boolean = true,
+    val dailySummaryEnabled: Boolean = false
+)
+
+val PreferencesStateSaver: Saver<PreferencesState, Any> = listSaver(
+    save = {
+        listOf(
+            it.locale.name,
+            it.themeMode.name,
+            it.remindersEnabled,
+            it.dailySummaryEnabled
+        )
+    },
+    restore = {
+        PreferencesState(
+            locale = UiLocale.valueOf(it[0] as String),
+            themeMode = ThemeMode.valueOf(it[1] as String),
+            remindersEnabled = it[2] as Boolean,
+            dailySummaryEnabled = it[3] as Boolean
+        )
+    }
+)
+
+data class TaskModel(
+    val id: String,
+    val title: String,
+    val notes: String = "",
+    val status: TaskStatus,
+    val priority: Priority,
+    val dueDate: LocalDate? = null,
+    val createdAt: LocalDateTime,
+    val updatedAt: LocalDateTime
+)
+
+data class RecurringRuleModel(
+    val id: String,
+    val name: String,
+    val cadence: Cadence,
+    val interval: Int,
+    val weekday: Weekday? = null,
+    val monthDay: Int? = null,
+    val startDate: LocalDate,
+    val endDate: LocalDate? = null,
+    val remindAt: String? = null,
+    val summaryChannel: SummaryChannel? = null
+)
+
+data class TrendPoint(
+    val label: String,
+    val completed: Int,
+    val created: Int
+)
+
+data class TaskDraft(
+    val title: String = "",
+    val notes: String = "",
+    val priority: Priority = Priority.Medium,
+    val dueDate: LocalDate? = null
+)
+
+data class RuleDraft(
+    val name: String = "",
+    val confirmName: String = "",
+    val cadence: Cadence? = null,
+    val interval: String = "1",
+    val weekday: Weekday? = null,
+    val monthDay: String = "",
+    val startDate: LocalDate = LocalDate.now(),
+    val hasEndDate: Boolean = false,
+    val endDate: LocalDate? = null,
+    val remindAt: String = "",
+    val enableSummary: Boolean = false,
+    val summaryChannel: SummaryChannel? = null
+)
+
+data class SchedulePreviewState(
+    val mode: PreviewMode,
+    val occurrences: List<LocalDate> = emptyList()
+)
+
+sealed interface UiText {
+    data class Resource(
+        val id: Int,
+        val args: List<Any> = emptyList()
+    ) : UiText
+
+    data class Literal(val value: String) : UiText
+}
+
+val TaskStatus.labelRes: Int
+    get() = when (this) {
+        TaskStatus.Open -> R.string.status_open
+        TaskStatus.Done -> R.string.status_done
+    }
+
+val Priority.labelRes: Int
+    get() = when (this) {
+        Priority.Low -> R.string.priority_low
+        Priority.Medium -> R.string.priority_medium
+        Priority.High -> R.string.priority_high
+    }
+
+val Weekday.labelRes: Int
+    get() = when (this) {
+        Weekday.Mon -> R.string.weekday_mon
+        Weekday.Tue -> R.string.weekday_tue
+        Weekday.Wed -> R.string.weekday_wed
+        Weekday.Thu -> R.string.weekday_thu
+        Weekday.Fri -> R.string.weekday_fri
+        Weekday.Sat -> R.string.weekday_sat
+        Weekday.Sun -> R.string.weekday_sun
+    }
+
+val Priority.color
+    @Composable get() = when (this) {
+        Priority.Low -> MaterialTheme.colorScheme.outline
+        Priority.Medium -> MaterialTheme.colorScheme.tertiary
+        Priority.High -> MaterialTheme.colorScheme.secondary
+    }
+
+@Composable
+fun UiText.resolve(): String {
+    return when (this) {
+        is UiText.Resource -> stringResource(id, *args.toTypedArray())
+        is UiText.Literal -> value
+    }
+}

package/examples/todo-orbit/generated/android/Todo Orbit/app/src/main/java/uz/rsteam/todoorbit/support/Strings.kt

@@ -0,0 +1,8 @@
+package uz.rsteam.todoorbit
+
+fun UiLocale.toLanguageTag(): String {
+    return when (this) {
+        UiLocale.En -> "en"
+        UiLocale.Ru -> "ru"
+    }
+}

package/examples/todo-orbit/generated/android/Todo Orbit/app/src/main/java/uz/rsteam/todoorbit/ui/components/CommonComponents.kt

@@ -0,0 +1,185 @@
+package uz.rsteam.todoorbit
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.FlowRow
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.Translate
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.ElevatedCard
+import androidx.compose.material3.FilterChip
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedCard
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Switch
+import androidx.compose.material3.Text
+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.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+
+@Composable
+fun HeroCard(title: String, subtitle: String) {
+    ElevatedCard(
+        shape = MaterialTheme.shapes.large,
+        colors = CardDefaults.elevatedCardColors(
+            containerColor = MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.65f)
+        )
+    ) {
+        Column(modifier = Modifier.padding(20.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+            Text(title, style = MaterialTheme.typography.headlineMedium, fontWeight = FontWeight.Bold)
+            Text(subtitle, style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.onSurfaceVariant)
+        }
+    }
+}
+
+@Composable
+fun StatCard(title: String, value: String) {
+    Card(shape = MaterialTheme.shapes.medium) {
+        Column(modifier = Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+            Text(title, style = MaterialTheme.typography.labelLarge, color = MaterialTheme.colorScheme.onSurfaceVariant)
+            Text(value, style = MaterialTheme.typography.headlineSmall, fontWeight = FontWeight.Bold)
+        }
+    }
+}
+
+@Composable
+fun LegendDot(color: Color, label: String) {
+    Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(6.dp)) {
+        Box(modifier = Modifier.size(10.dp).background(color, CircleShape))
+        Text(label, style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant)
+    }
+}
+
+@Composable
+fun LanguageSelector(current: UiLocale, onSelected: (UiLocale) -> Unit) {
+    EnumSelector(
+        title = stringResource(R.string.settings_language),
+        current = current.name,
+        options = listOf(
+            UiLocale.En.name to stringResource(R.string.settings_language_en),
+            UiLocale.Ru.name to stringResource(R.string.settings_language_ru)
+        ),
+        leadingIcon = {
+            Icon(Icons.Outlined.Translate, contentDescription = null, tint = MaterialTheme.colorScheme.onSurfaceVariant)
+        },
+        onSelected = { selected -> onSelected(UiLocale.entries.first { it.name == selected }) }
+    )
+}
+
+@Composable
+fun ThemeSelector(current: ThemeMode, onSelected: (ThemeMode) -> Unit) {
+    EnumSelector(
+        title = stringResource(R.string.settings_theme),
+        current = current.name,
+        options = listOf(
+            ThemeMode.Light.name to stringResource(R.string.settings_theme_light),
+            ThemeMode.Dark.name to stringResource(R.string.settings_theme_dark)
+        ),
+        onSelected = { selected -> onSelected(ThemeMode.entries.first { it.name == selected }) }
+    )
+}
+
+@OptIn(ExperimentalLayoutApi::class)
+@Composable
+fun EnumSelector(
+    title: String,
+    current: String,
+    options: List<Pair<String, String>>,
+    leadingIcon: @Composable (() -> Unit)? = null,
+    onSelected: (String) -> Unit
+) {
+    Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+        Text(title, style = MaterialTheme.typography.titleSmall)
+        FlowRow(horizontalArrangement = Arrangement.spacedBy(8.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+            options.forEach { (value, label) ->
+                FilterChip(
+                    selected = value == current,
+                    onClick = { onSelected(value) },
+                    label = { Text(label) },
+                    leadingIcon = if (value == current && leadingIcon != null) leadingIcon else null
+                )
+            }
+        }
+    }
+}
+
+@Composable
+fun SettingsToggle(
+    title: String,
+    subtitle: String,
+    checked: Boolean,
+    onCheckedChange: (Boolean) -> Unit
+) {
+    Row(
+        modifier = Modifier.fillMaxWidth(),
+        horizontalArrangement = Arrangement.SpaceBetween,
+        verticalAlignment = Alignment.CenterVertically
+    ) {
+        Column(modifier = Modifier.fillMaxWidth(0.8f), verticalArrangement = Arrangement.spacedBy(4.dp)) {
+            Text(title, fontWeight = FontWeight.SemiBold)
+            Text(subtitle, style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant)
+        }
+        Spacer(Modifier.width(12.dp))
+        Switch(checked = checked, onCheckedChange = onCheckedChange)
+    }
+}
+
+@Composable
+fun RuleTextField(
+    label: String,
+    value: String,
+    placeholder: String = "",
+    helper: String? = null,
+    error: String? = null,
+    onValueChange: (String) -> Unit
+) {
+    Column(verticalArrangement = Arrangement.spacedBy(6.dp)) {
+        OutlinedTextField(
+            value = value,
+            onValueChange = onValueChange,
+            modifier = Modifier.fillMaxWidth(),
+            label = { Text(label) },
+            placeholder = if (placeholder.isNotBlank()) ({ Text(placeholder) }) else null,
+            shape = MaterialTheme.shapes.medium,
+            isError = error != null
+        )
+        when {
+            error != null -> Text(error, color = MaterialTheme.colorScheme.error, style = MaterialTheme.typography.bodySmall)
+            helper != null -> Text(helper, color = MaterialTheme.colorScheme.onSurfaceVariant, style = MaterialTheme.typography.bodySmall)
+        }
+    }
+}
+
+@Composable
+fun EmptyCard(title: String, body: String) {
+    OutlinedCard(shape = MaterialTheme.shapes.large) {
+        Column(modifier = Modifier.padding(20.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+            Text(title, style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.SemiBold)
+            Text(body, color = MaterialTheme.colorScheme.onSurfaceVariant)
+        }
+    }
+}
+
+@Composable
+fun LabelValue(label: String, value: String) {
+    Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.SpaceBetween) {
+        Text(label, color = MaterialTheme.colorScheme.onSurfaceVariant)
+        Text(value, fontWeight = FontWeight.SemiBold)
+    }
+}

package/examples/todo-orbit/generated/android/Todo Orbit/app/src/main/java/uz/rsteam/todoorbit/ui/screens/AnalyticsScreen.kt

@@ -0,0 +1,193 @@
+package uz.rsteam.todoorbit
+
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.FlowRow
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+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.lazy.LazyColumn
+import androidx.compose.foundation.lazy.grid.GridCells
+import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
+import androidx.compose.material3.ElevatedCard
+import androidx.compose.material3.FilterChip
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.Path
+import androidx.compose.ui.graphics.StrokeCap
+import androidx.compose.ui.graphics.drawscope.Stroke
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+
+@OptIn(ExperimentalLayoutApi::class)
+@Composable
+fun AnalyticsScreen(
+    period: AnalyticsPeriod,
+    overview: AnalyticsOverview,
+    trendSeries: List<TrendPoint>,
+    overdueTasks: List<TaskModel>,
+    onPeriodChange: (AnalyticsPeriod) -> Unit,
+    locale: UiLocale
+) {
+    LazyColumn(
+        modifier = Modifier.fillMaxSize(),
+        verticalArrangement = Arrangement.spacedBy(16.dp),
+        contentPadding = PaddingValues(20.dp)
+    ) {
+        item {
+            HeroCard(
+                stringResource(R.string.analytics_title),
+                stringResource(R.string.analytics_subtitle)
+            )
+        }
+        item {
+            FlowRow(horizontalArrangement = Arrangement.spacedBy(8.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                AnalyticsPeriod.entries.forEach { entry ->
+                    FilterChip(
+                        selected = period == entry,
+                        onClick = { onPeriodChange(entry) },
+                        label = {
+                            Text(
+                                when (entry) {
+                                    AnalyticsPeriod.Week -> stringResource(R.string.analytics_period_week)
+                                    AnalyticsPeriod.Month -> stringResource(R.string.analytics_period_month)
+                                    AnalyticsPeriod.Quarter -> stringResource(R.string.analytics_period_quarter)
+                                }
+                            )
+                        }
+                    )
+                }
+            }
+        }
+        item {
+            LazyVerticalGrid(
+                columns = GridCells.Fixed(2),
+                modifier = Modifier.height(220.dp),
+                verticalArrangement = Arrangement.spacedBy(12.dp),
+                horizontalArrangement = Arrangement.spacedBy(12.dp),
+                userScrollEnabled = false
+            ) {
+                item { StatCard(stringResource(R.string.analytics_completed_today), overview.completedToday.toString()) }
+                item { StatCard(stringResource(R.string.analytics_open_tasks), overview.openTasks.toString()) }
+                item { StatCard(stringResource(R.string.analytics_overdue_tasks), overview.overdueTasks.toString()) }
+                item { StatCard(stringResource(R.string.analytics_completion_rate), "${overview.completionRate}%") }
+            }
+        }
+        item {
+            TrendChartCard(series = trendSeries, period = period)
+        }
+        item {
+            ElevatedCard(shape = MaterialTheme.shapes.large) {
+                Column(modifier = Modifier.padding(20.dp), verticalArrangement = Arrangement.spacedBy(12.dp)) {
+                    Text(stringResource(R.string.analytics_overdue_section), style = MaterialTheme.typography.headlineSmall)
+                    Text(stringResource(R.string.analytics_overdue_subtitle), color = MaterialTheme.colorScheme.onSurfaceVariant)
+                    if (overdueTasks.isEmpty()) {
+                        Text(stringResource(R.string.analytics_empty_overdue_body), color = MaterialTheme.colorScheme.onSurfaceVariant)
+                    } else {
+                        overdueTasks.forEach { task ->
+                            Row(modifier = Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.SpaceBetween) {
+                                Column {
+                                    Text(task.title, fontWeight = FontWeight.SemiBold)
+                                    Text(stringResource(task.priority.labelRes), color = MaterialTheme.colorScheme.onSurfaceVariant)
+                                }
+                                Text(task.dueDate?.let { formatAbsolute(it, locale) }.orEmpty())
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+@Composable
+fun TrendChartCard(
+    series: List<TrendPoint>,
+    period: AnalyticsPeriod
+) {
+    val outlineVariant = MaterialTheme.colorScheme.outlineVariant
+    val createdColor = MaterialTheme.colorScheme.secondary
+    val completedColor = MaterialTheme.colorScheme.primary
+
+    ElevatedCard(shape = MaterialTheme.shapes.large) {
+        Column(modifier = Modifier.padding(20.dp), verticalArrangement = Arrangement.spacedBy(16.dp)) {
+            Row(horizontalArrangement = Arrangement.SpaceBetween, modifier = Modifier.fillMaxWidth()) {
+                Column {
+                    Text(
+                        stringResource(R.string.analytics_contract_label),
+                        style = MaterialTheme.typography.labelSmall,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant
+                    )
+                    Text(
+                        when (period) {
+                            AnalyticsPeriod.Week -> stringResource(R.string.analytics_period_week)
+                            AnalyticsPeriod.Month -> stringResource(R.string.analytics_period_month)
+                            AnalyticsPeriod.Quarter -> stringResource(R.string.analytics_period_quarter)
+                        },
+                        style = MaterialTheme.typography.titleLarge
+                    )
+                }
+                Row(horizontalArrangement = Arrangement.spacedBy(12.dp)) {
+                    LegendDot(color = createdColor, label = stringResource(R.string.analytics_legend_created))
+                    LegendDot(color = completedColor, label = stringResource(R.string.analytics_legend_completed))
+                }
+            }
+            if (series.isEmpty()) {
+                Text(stringResource(R.string.analytics_empty_trend), color = MaterialTheme.colorScheme.onSurfaceVariant)
+            } else {
+                Canvas(modifier = Modifier.fillMaxWidth().height(220.dp)) {
+                    val maxValue = series.maxOf { maxOf(it.completed, it.created) }.coerceAtLeast(1)
+                    val leftPad = 32.dp.toPx()
+                    val bottomPad = 28.dp.toPx()
+                    val usableWidth = size.width - leftPad * 2
+                    val usableHeight = size.height - bottomPad - 20.dp.toPx()
+                    repeat(4) { index ->
+                        val y = 20.dp.toPx() + (usableHeight / 3f) * index
+                        drawLine(
+                            color = outlineVariant,
+                            start = Offset(leftPad, y),
+                            end = Offset(size.width - leftPad, y)
+                        )
+                    }
+                    fun buildPath(selector: (TrendPoint) -> Int): Path {
+                        return Path().apply {
+                            series.forEachIndexed { index, point ->
+                                val x = leftPad + (usableWidth / series.lastIndex.coerceAtLeast(1)) * index
+                                val y = 20.dp.toPx() + usableHeight - (usableHeight * selector(point) / maxValue.toFloat())
+                                if (index == 0) moveTo(x, y) else lineTo(x, y)
+                            }
+                        }
+                    }
+                    drawPath(
+                        path = buildPath { it.created },
+                        color = createdColor,
+                        style = Stroke(width = 6f, cap = StrokeCap.Round)
+                    )
+                    drawPath(
+                        path = buildPath { it.completed },
+                        color = completedColor,
+                        style = Stroke(width = 6f, cap = StrokeCap.Round)
+                    )
+                }
+                Row(horizontalArrangement = Arrangement.SpaceBetween, modifier = Modifier.fillMaxWidth()) {
+                    series.forEach { point ->
+                        Text(
+                            text = point.label,
+                            style = MaterialTheme.typography.labelSmall,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant
+                        )
+                    }
+                }
+            }
+        }
+    }
+}

package/examples/todo-orbit/generated/android/Todo Orbit/app/src/main/java/uz/rsteam/todoorbit/ui/screens/SettingsScreen.kt

@@ -0,0 +1,102 @@
+package uz.rsteam.todoorbit
+
+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.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.CalendarMonth
+import androidx.compose.material3.Button
+import androidx.compose.material3.ElevatedCard
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedCard
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+
+@Composable
+fun SettingsScreen(
+    preferences: PreferencesState,
+    recurringRules: List<RecurringRuleModel>,
+    onPreferencesChange: (PreferencesState) -> Unit,
+    onOpenRecurringRule: () -> Unit,
+    locale: UiLocale
+) {
+    LazyColumn(
+        modifier = Modifier.fillMaxSize(),
+        verticalArrangement = Arrangement.spacedBy(16.dp),
+        contentPadding = PaddingValues(20.dp)
+    ) {
+        item {
+            HeroCard(
+                stringResource(R.string.settings_title),
+                stringResource(R.string.settings_subtitle)
+            )
+        }
+        item {
+            ElevatedCard(shape = MaterialTheme.shapes.large) {
+                Column(modifier = Modifier.padding(20.dp), verticalArrangement = Arrangement.spacedBy(16.dp)) {
+                    LanguageSelector(
+                        current = preferences.locale,
+                        onSelected = { onPreferencesChange(preferences.copy(locale = it)) }
+                    )
+                    ThemeSelector(
+                        current = preferences.themeMode,
+                        onSelected = { onPreferencesChange(preferences.copy(themeMode = it)) }
+                    )
+                    SettingsToggle(
+                        title = stringResource(R.string.settings_reminders),
+                        subtitle = stringResource(R.string.settings_reminders_helper),
+                        checked = preferences.remindersEnabled,
+                        onCheckedChange = { onPreferencesChange(preferences.copy(remindersEnabled = it)) }
+                    )
+                    SettingsToggle(
+                        title = stringResource(R.string.settings_daily_summary),
+                        subtitle = stringResource(R.string.settings_daily_summary_helper),
+                        checked = preferences.dailySummaryEnabled,
+                        onCheckedChange = { onPreferencesChange(preferences.copy(dailySummaryEnabled = it)) }
+                    )
+                }
+            }
+        }
+        item {
+            ElevatedCard(shape = MaterialTheme.shapes.large) {
+                Column(modifier = Modifier.padding(20.dp), verticalArrangement = Arrangement.spacedBy(16.dp)) {
+                    Text(stringResource(R.string.settings_automation_title), style = MaterialTheme.typography.titleLarge)
+                    Text(stringResource(R.string.settings_automation_subtitle), color = MaterialTheme.colorScheme.onSurfaceVariant)
+                    Button(onClick = onOpenRecurringRule, shape = MaterialTheme.shapes.medium) {
+                        Icon(Icons.Outlined.CalendarMonth, contentDescription = null)
+                        Spacer(Modifier.width(8.dp))
+                        Text(stringResource(R.string.settings_automation_create_rule))
+                    }
+                    recurringRules.forEach { rule ->
+                        OutlinedCard(shape = MaterialTheme.shapes.medium) {
+                            Column(modifier = Modifier.padding(16.dp)) {
+                                Text(rule.name, fontWeight = FontWeight.SemiBold)
+                                Text(ruleDescription(rule, locale), color = MaterialTheme.colorScheme.onSurfaceVariant)
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun ruleDescription(rule: RecurringRuleModel, locale: UiLocale): String {
+    val cadence = when (rule.cadence) {
+        Cadence.Daily -> stringResource(R.string.recurring_rule_cadence_daily)
+        Cadence.Weekly -> "${stringResource(R.string.recurring_rule_cadence_weekly)} · ${stringResource(rule.weekday!!.labelRes)}"
+        Cadence.Monthly -> "${stringResource(R.string.recurring_rule_cadence_monthly)} · ${rule.monthDay}"
+    }
+    return "$cadence · ${formatAbsolute(rule.startDate, locale)}"
+}