kotlin {
    sourceSets {
        commonMain {
            dependencies {
                implementation("io.github.shivathapaa:nepali-date-picker-ui:<latest-version>")

                // Or, if you only need the date converter / calendar utilities (no UI):
                // implementation("io.github.shivathapaa:nepali-date-picker-core:<latest-version>")

                // Optional kotlinx-serialization support for the Nepali date types (3.1.0+):
                // implementation("io.github.shivathapaa:nepali-date-picker-serialization:<latest-version>")
            }
        }
    }
}

// Add the Compose compiler Gradle plugin to the Gradle version catalog
[versions]
# ...
kotlin = "2.4.20"
nepaliDatePicker = "3.3.0" // Check for latest release

[libraries]
nepali-date-picker-ui = { module = "io.github.shivathapaa:nepali-date-picker-ui", version.ref = "nepaliDatePicker" }
# Optional, only if you need the converter without the UI artifact:
# nepali-date-picker-core = { module = "io.github.shivathapaa:nepali-date-picker-core", version.ref = "nepaliDatePicker" }

[plugins]
# ...
compose-compiler = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }

// Add the Gradle plugin to the root/project level build.gradle.kts file
plugins {
    // ...
    alias(libs.plugins.compose.compiler) apply false // Kotlin version after 2.0.0
}

// Apply the plugin and dependency to app level build.gradle.kts file
plugins {
    // ...
    alias(libs.plugins.compose.compiler)
}

dependencies {
    // ...
    implementation(libs.nepali.date.picker.ui)
}

// Enable Desugaring in your build.gradle (app-level) file
android {
    compileOptions {
        // Enable core library desugaring for java.time (kotlinx-datetime) APIs
        isCoreLibraryDesugaringEnabled = true

        sourceCompatibility = JavaVersion.VERSION_1_8
        targetCompatibility = JavaVersion.VERSION_1_8
    }
}

// Add the Desugaring Dependency in the dependencies {} block of the same build.gradle file
dependencies {
    // Add this dependency for desugaring java.time(kotlinx-datetime) APIs
    coreLibraryDesugaring("com.android.tools:desugar_jdk_libs:2.1.3") // check for the latest

    // Other dependencies...
}

NepaliCalendarDefaults.NepaliYearRange   // 1970..2100 (Bikram Sambat)
NepaliCalendarDefaults.EnglishYearRange  // 1913..2043 (Gregorian)

Column {
    NepaliDatePicker(rememberNepaliDatePickerState())
}

// Every day paired with its Gregorian equivalent
Column {
    NepaliDatePickerWithEnglishDate(rememberNepaliDatePickerState())
}

// A range instead of a single date
Column {
    NepaliDateRangePicker(rememberNepaliDateRangePickerState())
}

Column {
    NepaliDateRangePickerWithEnglishDate(rememberNepaliDateRangePickerState())
}

val datePickerState = rememberNepaliDatePickerState()

NepaliDatePicker(state = datePickerState)

datePickerState.selectedDate        // CustomCalendar?, Bikram Sambat
datePickerState.selectedEnglishDate // the same day in Gregorian

var showNepaliDatePickerDialog by remember { mutableStateOf(false) }
val defaultNepaliDatePickerState = rememberNepaliDatePickerState()
val defaultNepaliDateRangePickerState = rememberNepaliDateRangePickerState()

if (showNepaliDatePickerDialog) {
    NepaliDatePickerDialog(
        confirmButton = {
            NepaliDatePickerDefaults.DialogButton(
                text = "OK",
                onButtonClick = { showNepaliDatePickerDialog = false }
            )
        },
        dismissButton = {
            NepaliDatePickerDefaults.DialogButton(
                text = "Cancel",
                onButtonClick = { showNepaliDatePickerDialog = false }
            )
        },
        onDismissRequest = { showNepaliDatePickerDialog = false }
    ) {
        NepaliDatePicker(state = defaultNepaliDatePickerState)
        // NepaliDatePickerWithEnglishDate(defaultNepaliDatePickerState)
        // NepaliDateRangePicker(defaultNepaliDateRangePickerState)
        // NepaliDateRangePickerWithEnglishDate(defaultNepaliDateRangePickerState)
    }
}

val state = rememberNepaliDatePickerState(
    initialSelectedDate = SimpleDate(2082, 2, 16),
    initialDisplayedMonth = SimpleDate(2082, 3),
    yearRange = IntRange(2082, 2083),
    initialDisplayMode = DisplayMode.Input,          // open on typed entry instead of the grid
    locale = NepaliDateLocale(language = NepaliDatePickerLang.NEPALI),
    nepaliSelectableDates = NepaliDateConverter.DateRangeSelectable(
        minDate = SimpleDate(2082, 2, 11),
        maxDate = SimpleDate(2083, 1, 29)
    )
)

NepaliDatePicker(state = state)

val state = rememberNepaliDatePickerState()

// One grid, either calendar, with the B.S. / A.D. switch and both dates in every cell.
NepaliDatePicker(
    state = state,
    secondaryDateLocale = NepaliDatePickerDefaults.DefaultLocale,
    showCalendarSystemToggle = true
)

// Open on the Gregorian grid instead, with no switch.
val englishFirstState = rememberNepaliDatePickerState(
    initialCalendarSystem = CalendarSystem.GREGORIAN
)

// Whatever is displayed, the selection reads the same way.
state.selectedDate        // CustomCalendar in Bikram Sambat (era = 2)
state.selectedEnglishDate // the same day in Gregorian (era = 1)

NepaliCalendarSystemToggle(
    calendarSystem = state.displayedCalendarSystem,
    onCalendarSystemChange = { state.displayedCalendarSystem = it }
)

NepaliWheelDatePicker(
    showCalendarSystemToggle = true,
    onDateChange = { bikramSambatDate -> /* always Bikram Sambat */ }
)

NepaliDateField(
    value = value,                              // a Bikram Sambat SimpleDate
    onValueChange = { value = it },             // also Bikram Sambat
    calendarSystem = CalendarSystem.GREGORIAN,  // but typed and shown in Gregorian
    showCalendarSystemToggle = true             // and switchable inside the dialog it opens
)

NepaliDatePicker(
    state = rememberNepaliDatePickerState(),
    showAdjacentMonthDays = true
)

NepaliDateConverter.getEnglishMonthCalendar(2026, 9)          // Gregorian month geometry
NepaliDateConverter.getEnglishCalendar(2026, 9, 17)           // a Gregorian CustomCalendar directly
NepaliDateConverter.getNepaliCalendarsInEnglishMonth(2026, 9) // BS for every day of a Gregorian month
NepaliDateConverter.getEnglishCalendarsInNepaliMonth(2083, 6) // and the mirror of it

// The same month with each day paired to its calendar, so a day with no Bikram Sambat
// equivalent stays distinguishable. This is also the form Swift callers get.
NepaliDateConverter.getNepaliCalendarsInEnglishMonthByDay(2026, 9)

// Every day of one Gregorian month, as Gregorian calendars.
NepaliDateConverter.getEnglishCalendarsInMonth(2026, 9)

NepaliDatePicker(
    state = rememberNepaliDatePickerState(),
    colors = NepaliDatePickerDefaults.colors()
        .copy(
            containerColor = MaterialTheme.colorScheme.surfaceContainer,
            dayContentColor = MaterialTheme.colorScheme.onSurface
        )
)

val nepaliLocale = NepaliDateLocale(
    language = NepaliDatePickerLang.NEPALI,
    dateFormat = NepaliDateFormatStyle.SHORT_YMD,
    weekDayName = NameFormat.MEDIUM,
    monthName = NameFormat.FULL
)

NepaliDatePicker(state = rememberNepaliDatePickerState(locale = nepaliLocale))

val todayNepaliDate = NepaliDateConverter.todayNepaliSimpleDate

// Everything up to and including today
val customDatePickerStateWithBeforeSelectable = rememberNepaliDatePickerState(
    initialSelectedDate = SimpleDate(2080, 3, 21),
    initialDisplayedMonth = SimpleDate(2081, 1, 1),
    yearRange = IntRange(1998, 2100),
    nepaliSelectableDates = NepaliDateConverter.BeforeDateSelectable(
        simpleDate = SimpleDate(
            todayNepaliDate.year,
            todayNepaliDate.month,
            todayNepaliDate.dayOfMonth
        ), includeDate = true
    ),
    locale = NepaliDateLocale(
        language = NepaliDatePickerLang.NEPALI,
        dateFormat = NepaliDateFormatStyle.SHORT_YMD,
        weekDayName = NameFormat.MEDIUM,
        monthName = NameFormat.FULL
    )
)

// Everything strictly after today
val customDatePickerStateWithAfterSelectable = rememberNepaliDatePickerState(
    yearRange = IntRange(1979, 2094),
    nepaliSelectableDates = NepaliDateConverter.AfterDateSelectable(
        simpleDate = SimpleDate(
            todayNepaliDate.year, todayNepaliDate.month, todayNepaliDate.dayOfMonth
        ),
        includeDate = false
    ),
    locale = NepaliDateLocale(
        language = NepaliDatePickerLang.ENGLISH,
        dateFormat = NepaliDateFormatStyle.COMPACT_YMD,
        weekDayName = NameFormat.FULL
    )
)

// A window between two dates
val customDatePickerStateWithRangeSelectable = rememberNepaliDatePickerState(
    initialDisplayedMonth = SimpleDate(2081, 12, 12),
    yearRange = IntRange(2079, 2090),
    nepaliSelectableDates = NepaliDateConverter.DateRangeSelectable(
        minDate = SimpleDate(
            todayNepaliDate.year, todayNepaliDate.month, todayNepaliDate.dayOfMonth
        ),
        maxDate = SimpleDate(2090, 1, 1),
        includeMinDate = false,
        includeMaxDate = true
    ),
    locale = NepaliDateLocale(
        language = NepaliDatePickerLang.ENGLISH,
        dateFormat = NepaliDateFormatStyle.COMPACT_YMD,
        weekDayName = NameFormat.FULL
    )
)

// Any rule of your own
val customSelectableDatePickerState = rememberNepaliDatePickerState(
    nepaliSelectableDates = object : NepaliSelectableDates {
        override fun isSelectableDate(customCalendar: CustomCalendar): Boolean {
            return customCalendar.month != 3 || (customCalendar.dayOfWeek != 7 && customCalendar.dayOfMonth != 15)
        }

        override fun isSelectableYear(year: Int): Boolean {
            return year >= 2054
        }
    }
)

val stateForPicker = NepaliDatePickerState(
    initialSelectedDate = SimpleDate(2081, 8, 21),
    initialDisplayedMonth = SimpleDate(2081, 7, 21),
    yearRange = IntRange(1998, 2100),
    nepaliSelectableDates = NepaliDatePickerDefaults.AllDates,
    initialDisplayMode = DisplayMode.Picker,
    locale = NepaliDatePickerDefaults.DefaultLocale
)

val stateForRangePicker = NepaliDateRangePickerState(
    initialSelectedStartNepaliDate = SimpleDate(2081, 8, 21),
    initialSelectedEndNepaliDate = SimpleDate(2081, 9, 21),
    initialDisplayedMonth = SimpleDate(2081, 7, 21),
    yearRange = IntRange(1998, 2100),
    nepaliSelectableDates = NepaliDatePickerDefaults.AllDates,
    initialDisplayMode = DisplayMode.Picker,
    locale = NepaliDatePickerDefaults.DefaultRangePickerLocale
)

NepaliDatePicker(state = stateForPicker)
NepaliDateRangePicker(state = stateForRangePicker)

// Simple date representation
data class SimpleDate(
    val year: Int,
    val month: Int,
    val dayOfMonth: Int = 1
)

// Simple time representation 
data class SimpleTime(
    val hour: Int,
    val minute: Int,
    val second: Int,
    val nanosecond: Int
)

// Custom Calendar for both English and Nepali dates
data class CustomCalendar(
    val year: Int,
    val month: Int,
    val dayOfMonth: Int,
    val era: Int,  // 1 for AD, 2 for BS
    val firstDayOfMonth: Int,
    val lastDayOfMonth: Int,
    val totalDaysInMonth: Int,
    val dayOfWeekInMonth: Int,
    val dayOfWeek: Int,
    val dayOfYear: Int,
    val weekOfMonth: Int,
    val weekOfYear: Int
)

// Nepali Month Calendar for month details
data class NepaliMonthCalendar(
    val year: Int,
    val month: Int,
    val totalDaysInMonth: Int,
    val firstDayOfMonth: Int,
    val lastDayOfMonth: Int,
    val daysFromStartOfWeekToFirstOfMonth: Int = firstDayOfMonth - 1
)

 // A data holder representing a CustomCalendar and SimpleTime
data class CustomDateTime(
    val customCalendar: CustomCalendar,
    val simpleTime: SimpleTime
)

// there are various extension function readily available to utilize all of them.

val todayNepaliDate = NepaliDateConverter.todayNepaliSimpleDate // returns SimpleDate
val todayNepaliCalendar = NepaliDateConverter.todayNepaliCalendar // returns CustomCalendar

val todayEnglishDate = NepaliDateConverter.todayEnglishSimpleDate // returns SimpleDate
val todayEnglishCalendar = NepaliDateConverter.todayEnglishCalendar // returns CustomCalendar

val currentTime = NepaliDateConverter.currentTime // returns SimpleTime

val convertedNepaliDate = NepaliDateConverter.convertEnglishToNepali(2021, 6, 21) // returns CustomCalendar

val convertedEnglishDate = NepaliDateConverter.convertNepaliToEnglish(2081, 3, 21) // returns CustomCalendar

NepaliDateConverter.getNepaliCalendar(2082, 4, 16) // returns CustomCalendar

val totalDaysInMagh2081 = NepaliDateConverter.getTotalDaysInNepaliMonth(2081, 10) // returns 30 (Int)

val getCompleteDetailsOfAsar2078Month = NepaliDateConverter.getNepaliMonthCalendar(2078, 3) // returns NepaliMonthCalendar

// Add 10 days to 2081-03-15
NepaliDateConverter.getNepaliCalendarAfterAdditionOrSubtraction(2081, 3, 15, 10)
// CustomCalendar(year = 2081, month = 3, dayOfMonth = 25, ...)

// Subtract 5 days from 2081-03-15
NepaliDateConverter.getNepaliCalendarAfterAdditionOrSubtraction(2081, 3, 15, -5)
// CustomCalendar(year = 2081, month = 3, dayOfMonth = 10, ...)

// Add 50 days, crossing into the next year
NepaliDateConverter.getNepaliCalendarAfterAdditionOrSubtraction(2081, 11, 15, 50)
// CustomCalendar(year = 2082, month = 1, dayOfMonth = 5, ...)

val compareDate = NepaliDateConverter.compareDates(convertedNepaliDate, SimpleDate(2090, 2, 12)) // returns 1, 0, -1 according to conditions

val noOfDaysBetweenTwoNepaliDates = NepaliDateConverter.getNepaliDaysInBetween(SimpleDate(1998, 11, 23), SimpleDate(2098, 4, 21))  // returns 36313

val noOfDaysBetweenTwoEnglishDates = NepaliDateConverter.getEnglishDaysInBetween(SimpleDate(2009, 6, 21), SimpleDate(2500, 3, 23)) // returns 179244

val currentTime = NepaliDateConverter.currentTime
val todayEnglishDate = NepaliDateConverter.todayEnglishSimpleDate
val todayNepaliDate = NepaliDateConverter.todayNepaliCalendar

val formattedEnglishDate = NepaliDateConverter.formatEnglishDateNepaliTimeToIsoFormat(todayEnglishDate, currentTime) // returns "2024-09-09T23:22:21Z"
val formattedNepaliDate = NepaliDateConverter.formatNepaliDateTimeToIsoFormat(todayNepaliDate.toSimpleDate(), currentTime) // returns "2024-09-09T23:22:21Z"

// A Bikram Sambat calendar and a Nepal-time clock reading.
NepaliDateConverter.getNepaliDateTimeFromIsoFormat("2024-09-09T09:00:15Z")
// CustomDateTime(customCalendar = CustomCalendar(year = 2081, month = 5, ...), simpleTime = SimpleTime(...))

// The Gregorian equivalent. Neither half needs the conversion table, so any year parses; the
// Bikram Sambat reading above is bounded by EnglishYearRange.
NepaliDateConverter.getEnglishDateNepaliTimeFromIsoFormat("2024-09-09T09:00:15Z")
// CustomDateTime(customCalendar = CustomCalendar(year = 2024, month = 9, ...), simpleTime = SimpleTime(...))

val weekday = NepaliDateConverter.getWeekdayName(2, NameFormat.FULL, NepaliDatePickerLang.NEPALI) // returns "सोमबार"
val weekdayEnglish = NepaliDateConverter.getWeekdayName(5, NameFormat.MEDIUM, NepaliDatePickerLang.ENGLISH) // returns Thu

val nepaliMonthName = NepaliDateConverter.getMonthName(12, NameFormat.FULL, NepaliDatePickerLang.NEPALI) // returns "चैत"
val nepaliMonthNameInEnglish = NepaliDateConverter.getMonthName(3, NameFormat.SHORT, NepaliDatePickerLang.ENGLISH) // returns Asa

val englishMonthName = NepaliDateConverter.getEnglishMonthName(6, NameFormat.FULL, NepaliDatePickerLang.NEPALI) // returns "जुन"

val currentTime = NepaliDateConverter.currentTime
val todayNepaliDate = NepaliDateConverter.todayNepaliCalendar

val customFormatLocale = NepaliDateLocale(
    language = NepaliDatePickerLang.NEPALI,
    dateFormat = NepaliDateFormatStyle.FULL,
    weekDayName = NameFormat.FULL,
    monthName = NameFormat.FULL
)

// From a CustomCalendar, which already knows its own weekday.
NepaliDateConverter.formatNepaliDate(todayNepaliDate, customFormatLocale)
// "सोमबार, असार २१, २०८२"
NepaliDateConverter.formatNepaliDate(todayNepaliDate, NepaliDatePickerDefaults.DefaultLocale)
// "Asar 21, 2082"

// From loose parts. The 4th argument is the weekday, which this overload does not derive, so
// pass the real one or the name will not match the date.
NepaliDateConverter.formatNepaliDate(2081, 3, 21, 6, NepaliDatePickerDefaults.DefaultLocale)
// "Asar 21, 2081"
NepaliDateConverter.formatEnglishDate(2024, 10, 3, 5, customFormatLocale)
// "बिहिबार, अक्टोबर ३, २०२४"

// Numerals follow the locale's digitScript when it is set, and its language when it is not, so a
// locale can pair Nepali month names with Latin digits or the reverse.
val nepaliNamesLatinDigits = NepaliDateLocale(
    language = NepaliDatePickerLang.NEPALI,
    dateFormat = NepaliDateFormatStyle.LONG,
    digitScript = DigitScript.LATIN
)
val mixedScriptDate = NepaliDateConverter.formatNepaliDate(2081, 5, 24, 2, nepaliNamesLatinDigits) // returns "भदौ 24, 2081"

val formattedNepaliTime = NepaliDateConverter.getFormattedTimeInNepali(simpleTime = currentTime, use12HourFormat = true) // returns "राति १२ : ०४"
val formattedEnglishTime = NepaliDateConverter.getFormattedTimeInEnglish(simpleTime = currentTime, use12HourFormat = false) // returns "0:04"

// The function supports the following placeholders in the unicodePattern:

// Date Components
// yyyy - Four-digit year (e.g., "2025" or "२०२५")
// yy - Two-digit year (e.g., "25" or "२५")
// MMMM - Full month name (e.g., "January" or "जनवरी")
// MMM - Abbreviated month name (e.g., "Jan" or "जन")
// MM - Two-digit month (e.g., "01" or "०१")
// M - Month number, no padding (e.g., "1" or "१")
// dd - Two-digit day of month (e.g., "04" or "०४")
// d - Day of month, no padding (e.g., "4" or "४")
// D - Day of the year (1–366) (e.g., "123" or "१२३")
// w - Week of the year (e.g., "23" or "२३")

// Weekday Components
// EEEE - Full weekday name (e.g., "Monday" or "सोमबार")
// E - Medium weekday name (e.g., "Mon" or "सोम")
// EEEEE - Short weekday name, if defined (e.g., "M" or "स")
// ee - Two-digit day of week (e.g., "02" or "०२")
// e - Day of week, no padding (e.g., "2" or "२")

// Time Components (24-hour and 12-hour)
// HH - Hour in 24-hour format (00–23) (e.g., "08" or "०८")
// H - Hour in 24-hour format, no padding (e.g., "8" or "८")
// hh - Hour in 12-hour format (01–12) (e.g., "01" or "०१")
// h - Hour in 12-hour format, no padding (e.g., "1" or "१")
// mm - Minutes, two-digit (e.g., "05" or "०५")
// m - Minutes, no padding (e.g., "5" or "५")
// ss - Seconds, two-digit (e.g., "09" or "०९")
// s - Seconds, no padding (e.g., "9" or "९")

// Fractional Seconds
// SSSS - Four-digit nanosecond precision (e.g., "1234" or "१२३४")
// SSS - Millisecond precision (e.g., "123" or "१२३")
// SS - Two-digit fractional seconds (e.g., "12" or "१२")
// S - One-digit fractional second (e.g., "1" or "१")

// Period Markers
// a - Lowercase AM/PM or localized period (e.g., "am" or "बिहान")
// A - Uppercase AM/PM or localized period (e.g., "AM" or "साँझ")

// Format time using a Unicode pattern
val time = NepaliDateConverter.currentTime

val result = NepaliDateConverter.formatTimeByUnicodePattern(
    unicodePattern = "hh:mm:ss a",
    time = time,
    language = NepaliDatePickerLang.NEPALI
) // result: "०२:४५:१५ दिउँसो"

val result = NepaliDateConverter.formatTimeByUnicodePattern(
    unicodePattern = "hh:mm:ss A",
    time = time,
    language = NepaliDatePickerLang.ENGLISH
) // result: "02:45:15 AM"

// Format only Nepali date using a Unicode pattern
val nepaliCalendar = NepaliDateConverter.todayNepaliCalendar

val result = NepaliDateConverter.formatNepaliDateByUnicodePattern(
    unicodePattern = "EEEE, MMM dd yyyy",
    calendar = nepaliCalendar,
    language = NepaliDatePickerLang.NEPALI // use ENGLISH for English
) // result: "सोमबार, भदौ २४ २०८१"

// Format only English date using a Unicode pattern
val englishCalendar = NepaliDateConverter.todayEnglishCalendar

val result = NepaliDateConverter.formatEnglishDateByUnicodePattern(
    unicodePattern = "E, MMM dd yyyy",
    calendar = englishCalendar,
    language = NepaliDatePickerLang.ENGLISH // use NEPALI for Nepali
) // result: "Sat, May 24 2025"

// Format full Nepali date and time using a Unicode pattern
val nepaliCalendar = NepaliDateConverter.todayNepaliCalendar
val time = NepaliDateConverter.currentTime

val result = NepaliDateConverter.formatNepaliDateTimeByUnicodePattern(
    unicodePattern = "yyyy MMMM dd, EEEE a hh:mm:ss",
    calendar = nepaliCalendar,
    time = time,
    language = NepaliDatePickerLang.NEPALI // use ENGLISH for English
) // result: "२०८१ भदौ २४, सोमबार दिउँसो ०२:४५:१५"

// Format full English date and time using a Unicode pattern
val englishCalendar = NepaliDateConverter.todayEnglishCalendar
val time = NepaliDateConverter.currentTime

val result = NepaliDateConverter.formatEnglishDateTimeByUnicodePattern(
    unicodePattern = "yyyy MMMM dd, EEEE hh:mm:ss A",
    calendar = englishCalendar,
    time = time,
    language = NepaliDatePickerLang.ENGLISH // use NEPALI for Nepali
) // result: "2025 May 24, Monday 02:45:15 PM"

val nepaliString = "Today is 2024".localizeDigits(DigitScript.DEVANAGARI) // returns "Today is २०२४"
val nepaliStringOnlyDigits = "2024".localizeDigits(DigitScript.DEVANAGARI) // returns "२०२४"
val englishString = "२०२४ सोमबार".toLatinDigits() // returns "2024 सोमबार"

// Or resolve the script from a locale
val localizeString = "Today is 2024".localizeDigits(NepaliDateLocale(language = NepaliDatePickerLang.NEPALI)) // returns "Today is २०२४"

// Deprecated (still functional, with ReplaceWith):
// "Today is 2024".convertToNepaliNumber()  ->  localizeDigits(DigitScript.DEVANAGARI)
// "२०२४".convertToEnglishNumber()          ->  toLatinDigits()

NepaliDateConverter.replaceDelimiter("2024/06/21", "-")     // "2024-06-21"
NepaliDateConverter.replaceDelimiter("२०२४/०६/२१", "-")      // "२०२४-०६-२१"
NepaliDateConverter.replaceDelimiter("09:45 AM", " ", ":")  // "09 45 AM"

val dashain = NepaliCalendarEvent(
    date = SimpleDate(2082, 6, 25),
    name = "Vijaya Dashami",
    kind = NepaliEventKind.Religious,   // colours the day, and sets the default below
    closesOffices = true,               // the event has the final say, not its kind
    id = "evt-42",                      // handed back untouched, to find your own record
    payload = """{"images":["dashain.png"]}"""   // opaque; the library never parses it
)

object OfficeCalendar : NepaliEventProvider {
    private val byYear = mapOf(2082 to setOf(dashain))
    override fun events(year: Int): Set<NepaliCalendarEvent> = byYear[year].orEmpty()
}

val dashain = NepaliCalendarEvent(
    date = SimpleDate(2082, 6, 17),
    name = "Dashain",
    kind = NepaliEventKind.Religious,
    id = "dashain-2082"       // set it, so the days can be recognized as one thing again
)

dashain.spanningDays(10)                           // ten entries, Asoj 17 through 26
dashain.spanningThrough(SimpleDate(2082, 6, 26))   // the same span, stated by its end

// Fold the days back into one agenda row.
office.eventsIn(2082, 6).distinctBy { it.id ?: it.name }

// The week an institution never opens, plus the events it keeps. Stated once, used everywhere.
val office = NepaliCalendarPolicy(provider = OfficeCalendar)                   // Saturday off
val school = NepaliCalendarPolicy(setOf(7, 1), OfficeCalendar)                 // Sat + Sun off
val merged = NepaliCalendarPolicy(setOf(7, 1), OfficeCalendar + schoolsOwnList) // two lists at once

// Weekday numbers are 1-based-Sunday. A set written to JavaScript's 0-based convention would close
// nothing at all, so it throws instead of failing quietly.
NepaliCalendarPolicy(weeklyOffDays = setOf(0, 6))  // IllegalArgumentException

// Narrow a shared list to what one screen cares about.
val closuresOnly = OfficeCalendar.filtered { it.closesOffices }

import dev.shivathapaa.nepalidatepickerkmp.event.addWorkingDays
import dev.shivathapaa.nepalidatepickerkmp.event.nextWorkingDay
import dev.shivathapaa.nepalidatepickerkmp.event.workingDaysBetween

NepaliDateConverter.workingDaysBetween(start, end, school)  // end exclusive
NepaliDateConverter.nextWorkingDay(from, school)            // `from` itself if it is a working day
NepaliDateConverter.addWorkingDays(from, 10, school)        // Excel WORKDAY semantics, negatives walk back

val status = office.statusOf(SimpleDate(2082, 6, 3))
status.isWeeklyOff    // the week closes the day
status.isNonWorking   // closed for either reason, counted once
status.primaryKind    // null when the day is only a weekly off day
status.names          // ["Constitution Day"], strongest kind first
status.events         // the same events in full, with your id and payload
status.closures       // only the ones that actually shut the door

office.eventsOn(SimpleDate(2082, 6, 3))  // one day
office.eventsIn(2082, 6)                 // a whole month, in date order
office.monthStatus(2082, 6)              // one entry per day; index 0 is day 1

// A day-detail panel, the way the sample's Events tab draws it.
val selected = state.selectedDate?.toSimpleDate()
val status = selected?.let { office.statusOf(it) }
when {
    status == null -> Text("Pick a day")
    status.names.isNotEmpty() -> Text(status.names.joinToString())
    status.isWeeklyOff -> Text("Weekly day off")
    else -> Text("A working day")
}

// Holidays and the weekly rule, coloured from MaterialTheme.colorScheme.
NepaliDatePicker(
    state = rememberNepaliDatePickerState(),
    dayDecorator = NepaliDatePickerDefaults.eventDecorator(policy = office)
)

// Every channel is a switch, and every colour falls back to the theme unless you override it, so
// light and dark both work untouched.
NepaliDatePicker(
    state = rememberNepaliDatePickerState(),
    dayDecorator = NepaliDatePickerDefaults.eventDecorator(
        policy = school,
        colors = NepaliDatePickerDefaults.markerColors(
            weeklyOffColor = MaterialTheme.colorScheme.outline,
            religiousColor = MaterialTheme.colorScheme.tertiary
        ),
        style = NepaliDatePickerDefaults.eventDisplayStyle(
            tintContainer = true,                                     // a tinted disc as well
            indicateKinds = setOf(NepaliEventKind.GovernmentPublic)   // opt this kind into a dot
        )
    )
)

// Your own events, straight from maps keyed by date.
NepaliDatePicker(
    state = rememberNepaliDatePickerState(),
    dayDecorator = NepaliDatePickerDefaults.dayDecorator(
        markers = mapOf(SimpleDate(2082, 6, 3) to listOf(MaterialTheme.colorScheme.primary)),
        descriptions = mapOf(SimpleDate(2082, 6, 3) to "Standup, Aama's birthday")
    )
)

// A holiday and a meeting on the same day: `then` layers them, the leader keeps the colour and
// both keep their dots.
NepaliDatePicker(
    state = rememberNepaliDatePickerState(),
    dayDecorator = NepaliDatePickerDefaults.eventDecorator(policy = office)
        .then(NepaliDatePickerDefaults.dayDecorator(markers = myEventsByDate))
)

// Anything else: one lambda per day. It runs outside composition, so read the theme before it.
val eventColor = MaterialTheme.colorScheme.primary
val decorator = remember(events, eventColor) {
    NepaliDayDecorator { day ->                       // day: NepaliDayInfo
        val onThatDay = events[day.date.toSimpleDate()] ?: return@NepaliDayDecorator null
        NepaliDayDecoration(
            contentColor = eventColor,                 // Color.Unspecified keeps the theme's
            indicators = onThatDay.map { eventColor }, // three dots at most, two in a dual-date grid
            contentDescription = onThatDay.joinToString { it.title }  // spoken after the date
        )
    }
}
NepaliDatePicker(state = rememberNepaliDatePickerState(), dayDecorator = decorator)

val state = rememberNepaliDatePickerState(
    nepaliSelectableDates = school.asSelectableDates()   // weekly off days and closures greyed out
)
NepaliDatePicker(state = state, dayDecorator = NepaliDatePickerDefaults.eventDecorator(school))

val bookable = NepaliDateConverter.AfterDateSelectable(today, includeDate = true)
    .excludingWeekends(school.weeklyOffDays)
    .excludingClosures(school.provider)

@Serializable
data class CachedYear(val year: Int, val events: List<@Contextual NepaliCalendarEvent>)

val json = Json { serializersModule = NepaliDatePickerSerializersModule }
json.encodeToString(CachedYear(2082, listOf(dashain)))
// {"year":2082,"events":[{"date":"2082-06-25","name":"Vijaya Dashami","kind":"Religious","id":"evt-42", ...}]}