🥮 mooncakes.io

    moonbit-deadline

    Deterministic legal and contract deadline calculations with injectable business calendars.

    deadline
    legal
    calendar
    business-day
    moonbit
    Download zip
    Author
    Version
    0.1.1
    License
    MIT
    Repository
    Last updated
    2 months ago
    Downloads
    34

    No dependencies

    #moonbit-deadline

    moonbit-deadline 是一个纯 MoonBit 的法律、合同和合规期限计算库。它把起算事件、计数规则、工作日历、顺延策略、暂停区间和审计输出组合成可复用的确定性 API。

    它只计算日期，不提供法律意见。使用者应自行确认适用法域、送达规则、法院日历和合同条款，并注入经过审核的日历数据。

    #特性

    • 自然日、工作日、周、月、年和序列期限。
    • 起算日计入/排除、Following、Modified Following 和 Preceding 顺延。
    • 可注入周末、节假日、调休、观察日、版本和来源的工作日历。
    • 事件起算、暂停区间、批量依赖计划、跨日历矩阵和期限预测。
    • 期限窗口、约束校验、完成回执、状态台账和提醒计划。
    • 日历统计、差异比较、时间线 CSV/Markdown、审计文本/表格/CSV 输出。
    • MoonBit 库 API、命令行示例和独立 benchmark workload。

    #快速开始

    运行一个“起算日不计入、顺延到下一个工作日”的期限：

    moon run cmd/deadline -- --start 2026-08-07 --rule business-days:5 --exclude-start --extension following --explain

    规则格式为 calendar-days:N、business-days:N、weeks:N、months:N 或 years:N；逗号可以串联多个阶段。

    calendar=standard
version=builtin
region=
source=
source_url=
start=2026-08-07
original=2026-08-14
adjusted=2026-08-14
adjustments=0
crossed_month=false
crossed_year=false

    表格输出：

    moon run cmd/deadline -- --start 2026-08-07 --rule business-days:5 --exclude-start --format table

    #库 API

    let calendar = @deadline.Calendar::china_2026()
    let deadline = @deadline.Deadline::new(
      start_date=@deadline.Date::parse("2026-04-30").unwrap(),
      rule=@deadline.DateRule::business_days(1),
      start_rule=@deadline.StartDateRule::exclude(),
      calendar~,
      extension=@deadline.ExtensionPolicy::following(),
    )
    let result = deadline.calculate().unwrap()
    println(result.summary())
    println(@deadline.AuditReport::from_result(result, calendar).to_text())

    模块名是 chyppi/moonbit-deadline。核心类型包括 Date、DateRule、Deadline、Calendar、EventContext、BatchDeadline、DeadlineRecord 和 AuditReport。

    设计边界和计算模型见 Design overview。

    #日历数据

    Calendar::china_2026() 是可复现的示例 fixture，版本标记为 2025-11-04，日期来自国务院办公厅节假日安排通知的北京市人民政府转载页面：官方政策页面。它不代表所有地区、法院、行业或合同的完整日历。

    业务方可以使用 CalendarBuilder 构建自定义日历，使用 CalendarCatalog 管理多个版本，并用 Calendar::diff 检查数据更新。

    #Benchmark

    benchmark 运行真实的日历查询、工作日期限和批量期限计算，并输出 checksum，避免空循环被误计为性能结果：

    moon run bench/deadline_bench -- --iterations 10

    本地一次运行（Moon 0.1.20260819 / Moonc 0.10.9，100 次迭代）得到：

    case=calendar iterations=100 checksum=48818044
case=deadline iterations=100 checksum=73967272
case=batch iterations=100 checksum=73983800

    耗时应由运行机器的外层命令测量；以上 checksum 用于确认 workload 确实完成了计算。

    #开发与验证

    moon check --target all --deny-warn
moon test --target wasm-gc --deny-warn
moon run cmd/deadline -- --start 2026-08-07 --rule business-days:5 --exclude-start --extension following --explain
moon run bench/deadline_bench -- --iterations 100
moon fmt
moon info
git diff --exit-code

    scripts/audit.ps1 会输出工具链版本、项目 .mbt 文件清单、测试数、远程默认分支和工作区状态；清单排除 _build、.moon、缓存和 pkg.generated.mbti。

    CI 使用 MoonBit stable 安装脚本，覆盖 Linux、macOS 和 Windows；Linux/macOS 运行全目标检查，Windows 运行 wasm、wasm-gc 和 js 便携目标，并统一执行格式化和接口生成差异门禁。Windows native 目标依赖运行器提供兼容的 MSVC/Clang C 工具链。

    #贡献

    请为规则、日历数据和边界行为添加聚焦测试。日历数据变更应记录适用地区、来源和有效版本。提交前请阅读 CONTRIBUTING.md。

    #许可证

    MIT，见 LICENSE。

    AuditReport

    source
    pub struct AuditReport {
      result : DeadlineResult
      calendar : Calendar
    }

    A stable, human-readable view of a calculated deadline.

    AuditReport::from_result

    source
    fn AuditReport::from_result(result : DeadlineResult, calendar : Calendar) -> AuditReport

    Build a report from an existing result and its calendar.

    AuditReport::to_csv

    source
    fn AuditReport::to_csv(self : AuditReport) -> String

    Export calculation steps as a CSV stream for spreadsheets and ETL tools.

    AuditReport::to_table

    source
    fn AuditReport::to_table(self : AuditReport) -> String

    Render only the step table for terminal and downstream parsing use.

    AuditReport::to_text

    source
    fn AuditReport::to_text(self : AuditReport) -> String

    Render metadata followed by the calculation steps.

    BatchDeadline

    source
    pub struct BatchDeadline {
      tasks : Array[BatchTask]
    }

    BatchDeadline::add

    source
    fn BatchDeadline::add(self : BatchDeadline, task : BatchTask) -> Result[BatchDeadline, BatchError]

    Add a uniquely named task without mutating the original batch.

    BatchDeadline::calculate

    source
    fn BatchDeadline::calculate(self : BatchDeadline, context : EventContext) -> Result[BatchResult, BatchError]

    Calculate all tasks in dependency order.

    BatchDeadline::new

    source

    Start an empty batch.

    BatchError

    source
    pub enum BatchError {
      BatchDuplicate(String)
      BatchMissingDependency(String)
      BatchCycle(String)
      BatchEmpty
      BatchEventFailure(EventError)
      BatchDeadlineFailure(DeadlineError)
    } derive(
    Debug    )

    BatchResult

    source
    pub struct BatchResult {
      entries : Array[BatchResultEntry]
    }

    BatchResult::explain

    source
    fn BatchResult::explain(self : BatchResult) -> String

    Render a compact audit summary for the complete batch.

    BatchResult::get

    source
    fn BatchResult::get(self : BatchResult, name : String) -> DeadlineResult?

    Look up one calculated task.

    BatchResult::ordered

    source
    fn BatchResult::ordered(self : BatchResult) -> Array[String]

    Return task names in deterministic calculation order.

    BatchResultEntry

    source
    type BatchResultEntry

    BatchTask

    source
    pub struct BatchTask {
      name : String
      event : String?
      dependency : String?
      rule : DateRule
      start_rule : StartDateRule
      calendar : Calendar
      extension : ExtensionPolicy
    }

    A named deadline in a batch calculation.

    BatchTask::after

    source
    fn BatchTask::after(name~ : String, dependency~ : String, rule~ : DateRule, start_rule~ : StartDateRule, calendar~ : Calendar, extension~ : ExtensionPolicy) -> BatchTask

    Define a task that starts at another task's adjusted result.

    BatchTask::from_event

    source
    fn BatchTask::from_event(name~ : String, event~ : String, rule~ : DateRule, start_rule~ : StartDateRule, calendar~ : Calendar, extension~ : ExtensionPolicy) -> BatchTask

    Define a task that starts at an event in an EventContext.

    BusinessDayCursor

    source
    pub struct BusinessDayCursor {
      date : Date
      calendar : Calendar
    }

    A stateless cursor anchor for repeatable business-day navigation.

    BusinessDayCursor::forward

    source
    fn BusinessDayCursor::forward(self : BusinessDayCursor, count : Int) -> Result[Array[Date], CursorError]

    Collect a forward sequence, excluding the anchor.

    BusinessDayCursor::new

    source
    fn BusinessDayCursor::new(date~ : Date, calendar~ : Calendar) -> BusinessDayCursor

    Create a cursor anchored at a date.

    BusinessDayCursor::next

    source

    Find the first business day after the anchor.

    BusinessDayCursor::previous

    source
    fn BusinessDayCursor::previous(self : BusinessDayCursor) -> Result[Date, CursorError]

    Find the first business day before the anchor.

    BusinessDaySeries

    source
    pub struct BusinessDaySeries {
      calendar : Calendar
      start : Date
      end : Date
    }

    BusinessDaySeries::collect

    source

    Collect only business dates in the interval.

    BusinessDaySeries::new

    source
    fn BusinessDaySeries::new(calendar~ : Calendar, start~ : Date, end~ : Date) -> Result[BusinessDaySeries, SeriesError]

    Create a materialized business-day series over a closed interval.

    CalculationStep

    source
    pub struct CalculationStep {
      kind : StepKind
      date : Date
      note : String
    } derive(
    Debug    )

    CalculationStep::date

    source

    CalculationStep::kind

    source

    CalculationStep::note

    source
    fn CalculationStep::note(self : CalculationStep) -> String

    Calendar

    source
    pub struct Calendar {
      name : String
      version : String
      region : String
      source : CalendarSource
      valid_from : Date
      valid_to : Date
      versioned : Bool
      weekend : WeekendPolicy
      holidays : Array[Date]
      extra_workdays : Array[Date]
      observed_holidays : Array[Date]
    } derive(
    Debug    )

    Calendar::advance_business_days

    source
    fn Calendar::advance_business_days(self : Calendar, start : Date, count : Int, include_start? : Bool) -> Result[Date, CalendarError]

    Calendar::china_2026

    source
    fn Calendar::china_2026() -> Calendar

    The date list is intentionally explicit so callers can replace it with their own jurisdiction, court, or contract calendar without changing the deadline engine.

    Calendar::dates_between

    source
    fn Calendar::dates_between(self : Calendar, start~ : Date, end~ : Date, filter~ : CalendarDateFilter) -> Result[Array[Date], CalendarValidationError]

    Return dates matching one calendar classification in ascending order.

    Calendar::diff

    source
    fn Calendar::diff(left : Calendar, right : Calendar) -> CalendarDiff

    Compare closure and exceptional-workday data from two calendars.

    Calendar::is_business_day

    source
    fn Calendar::is_business_day(self : Calendar, date : Date) -> Bool

    Calendar::merge

    source
    fn Calendar::merge(primary : Calendar, secondary : Calendar) -> Result[Calendar, CalendarValidationError]

    Combine a primary calendar with a fallback calendar.

    Calendar::name

    source
    fn Calendar::name(self : Calendar) -> String

    Calendar::new

    source
    fn Calendar::new(name~ : String, version~ : String, weekend~ : WeekendPolicy, holidays~ : Array[Date], extra_workdays~ : Array[Date]) -> Calendar

    Calendar::next_business_day

    source
    fn Calendar::next_business_day(self : Calendar, date : Date) -> Result[Date, CalendarError]

    Calendar::observed_date

    source
    fn Calendar::observed_date(self : Calendar, date : Date) -> Date

    Calendar::observed_holidays

    source
    fn Calendar::observed_holidays(self : Calendar) -> Array[Date]

    Calendar::previous_business_day

    source
    fn Calendar::previous_business_day(self : Calendar, date : Date) -> Result[Date, CalendarError]

    Calendar::query

    source
    fn Calendar::query(self : Calendar, date : Date) -> CalendarDayInfo

    Explain the classification of one date under this calendar.

    Calendar::region

    source
    fn Calendar::region(self : Calendar) -> String

    Calendar::source

    source
    fn Calendar::source(self : Calendar) -> CalendarSource

    Calendar::standard

    source
    fn Calendar::standard() -> Calendar

    Calendar::summarize

    source
    fn Calendar::summarize(self : Calendar, start~ : Date, end~ : Date) -> Result[CalendarSummary, CalendarValidationError]

    Count calendar classifications over an inclusive interval.

    Calendar::valid_from

    source
    fn Calendar::valid_from(self : Calendar) -> Date

    Calendar::valid_to

    source
    fn Calendar::valid_to(self : Calendar) -> Date

    Calendar::validate

    source
    fn Calendar::validate(self : Calendar) -> Result[Unit, CalendarValidationError]

    Validate a calendar assembled by any API.

    Calendar::version

    source
    fn Calendar::version(self : Calendar) -> String

    Calendar::with_observed_holidays

    source
    fn Calendar::with_observed_holidays(self : Calendar, observed_holidays : Array[Date]) -> Result[Calendar, CalendarVersionError]

    Calendar::with_version

    source
    fn Calendar::with_version(self : Calendar, version : CalendarVersion) -> Calendar

    CalendarBuilder

    source
    pub struct CalendarBuilder {
      name : String
      version : String
      region : String
      source : CalendarSource
      valid_from : Date?
      valid_to : Date?
      weekend : WeekendPolicy
      holidays : Array[Date]
      extra_workdays : Array[Date]
    }

    A small immutable builder for calendars assembled by an application.

    CalendarBuilder::build

    source

    Validate and build a calendar.

    CalendarBuilder::extra_workday

    source
    fn CalendarBuilder::extra_workday(self : CalendarBuilder, date : Date) -> CalendarBuilder

    Add an exceptional workday, which has priority over closure dates.

    CalendarBuilder::holiday

    source
    fn CalendarBuilder::holiday(self : CalendarBuilder, date : Date) -> CalendarBuilder

    Add a holiday. Duplicate dates are removed during build.

    CalendarBuilder::new

    source
    fn CalendarBuilder::new(name~ : String, version~ : String, weekend~ : WeekendPolicy) -> CalendarBuilder

    Start assembling a calendar with explicit identity and weekend policy.

    CalendarBuilder::region

    source
    fn CalendarBuilder::region(self : CalendarBuilder, region : String) -> CalendarBuilder

    Set a jurisdiction or organization label.

    CalendarBuilder::source

    source

    Set the source metadata for the assembled calendar.

    CalendarBuilder::valid_during

    source
    fn CalendarBuilder::valid_during(self : CalendarBuilder, start~ : Date, end~ : Date) -> CalendarBuilder

    Set the inclusive validity interval.

    CalendarCatalog

    source
    pub struct CalendarCatalog {
      entries : Array[CatalogEntry]
    }

    A validated collection of named calendar versions.

    CalendarCatalog::add

    source
    fn CalendarCatalog::add(self : CalendarCatalog, calendar : Calendar) -> Result[CalendarCatalog, CatalogError]

    Add a calendar after validating its metadata.

    CalendarCatalog::find

    source
    fn CalendarCatalog::find(self : CalendarCatalog, name : String, version : String) -> Calendar?

    Find an exact name/version pair.

    CalendarCatalog::names

    source
    fn CalendarCatalog::names(self : CalendarCatalog) -> Array[String]

    Return stable catalog identities in insertion order.

    CalendarCatalog::new

    source

    Create an empty calendar catalog.

    CalendarCatalog::validate

    source
    fn CalendarCatalog::validate(self : CalendarCatalog) -> Result[Unit, CatalogError]

    Revalidate all calendars in the catalog.

    CalendarDateFilter

    source
    pub enum CalendarDateFilter {
      BusinessDays
      Closures
      Holidays
      ObservedHolidays
      ExtraWorkdays
    } derive(Compare, Eq, 
    Debug    )

    CalendarDateFilter::business_days

    source
    fn CalendarDateFilter::business_days() -> CalendarDateFilter

    CalendarDateFilter::closures

    source

    CalendarDateFilter::extra_workdays

    source
    fn CalendarDateFilter::extra_workdays() -> CalendarDateFilter

    CalendarDateFilter::holidays

    source

    CalendarDateFilter::observed_holidays

    source
    fn CalendarDateFilter::observed_holidays() -> CalendarDateFilter

    CalendarDayInfo

    source
    pub struct CalendarDayInfo {
      date : Date
      kind : CalendarDayKind
      calendar_name : String
      calendar_version : String
    }

    CalendarDayInfo::calendar_name

    source
    fn CalendarDayInfo::calendar_name(self : CalendarDayInfo) -> String

    Calendar identity returned by a query.

    CalendarDayInfo::calendar_version

    source
    fn CalendarDayInfo::calendar_version(self : CalendarDayInfo) -> String

    Calendar version returned by a query.

    CalendarDayInfo::date

    source

    Date returned by a calendar query.

    CalendarDayInfo::kind

    source

    Classification returned by a calendar query.

    CalendarDayKind

    source
    pub enum CalendarDayKind {
      BusinessDay
      Weekend
      Holiday
      ObservedHoliday
    } derive(Compare, Eq, 
    Debug    )

    CalendarDayKind::to_string

    source
    fn CalendarDayKind::to_string(self : CalendarDayKind) -> String

    CalendarDiff

    source
    pub struct CalendarDiff {
      only_left : Array[Date]
      only_right : Array[Date]
      shared : Array[Date]
      extra_only_left : Array[Date]
      extra_only_right : Array[Date]
      observed_only_left : Array[Date]
      observed_only_right : Array[Date]
      observed_shared : Array[Date]
    }

    Difference sets between two holiday/workday calendars.

    CalendarDiff::extra_workdays_only_left

    source
    fn CalendarDiff::extra_workdays_only_left(self : CalendarDiff) -> Array[Date]

    CalendarDiff::extra_workdays_only_right

    source
    fn CalendarDiff::extra_workdays_only_right(self : CalendarDiff) -> Array[Date]

    CalendarDiff::observed_holidays_only_left

    source
    fn CalendarDiff::observed_holidays_only_left(self : CalendarDiff) -> Array[Date]

    Observed holidays present only in the left calendar.

    CalendarDiff::observed_holidays_only_right

    source
    fn CalendarDiff::observed_holidays_only_right(self : CalendarDiff) -> Array[Date]

    Observed holidays present only in the right calendar.

    CalendarDiff::only_left

    source
    fn CalendarDiff::only_left(self : CalendarDiff) -> Array[Date]

    CalendarDiff::only_right

    source
    fn CalendarDiff::only_right(self : CalendarDiff) -> Array[Date]

    CalendarDiff::shared

    source
    fn CalendarDiff::shared(self : CalendarDiff) -> Array[Date]

    CalendarDiff::shared_observed_holidays

    source
    fn CalendarDiff::shared_observed_holidays(self : CalendarDiff) -> Array[Date]

    Observed holidays shared by both calendars.

    CalendarDiff::to_text

    source
    fn CalendarDiff::to_text(self : CalendarDiff) -> String

    Render changed closure dates as stable key/value lines.

    CalendarError

    source
    pub enum CalendarError {
      NegativeBusinessDayCount
      DateOutOfRange
    } derive(Compare, Eq, 
    Debug    )

    CalendarSource

    source
    pub struct CalendarSource {
      name : String
      url : String
    } derive(Compare, Eq, 
    Debug    )

    CalendarSource::name

    source
    fn CalendarSource::name(self : CalendarSource) -> String

    CalendarSource::new

    source
    fn CalendarSource::new(name~ : String, url~ : String) -> CalendarSource

    CalendarSource::url

    source
    fn CalendarSource::url(self : CalendarSource) -> String

    CalendarSummary

    source
    pub struct CalendarSummary {
      start : Date
      end : Date
      total_days : Int
      business_days : Int
      weekend_days : Int
      holiday_days : Int
      observed_holiday_days : Int
      extra_workdays : Int
      first_business : Date?
      last_business : Date?
    }

    A deterministic summary of a calendar over a closed date range.

    CalendarSummary::business_days

    source
    fn CalendarSummary::business_days(self : CalendarSummary) -> Int

    CalendarSummary::end

    source

    CalendarSummary::extra_workdays

    source
    fn CalendarSummary::extra_workdays(self : CalendarSummary) -> Int

    CalendarSummary::first_business_day

    source
    fn CalendarSummary::first_business_day(self : CalendarSummary) -> Date?

    CalendarSummary::holiday_days

    source
    fn CalendarSummary::holiday_days(self : CalendarSummary) -> Int

    CalendarSummary::last_business_day

    source
    fn CalendarSummary::last_business_day(self : CalendarSummary) -> Date?

    CalendarSummary::observed_holiday_days

    source
    fn CalendarSummary::observed_holiday_days(self : CalendarSummary) -> Int

    CalendarSummary::start

    source
    fn CalendarSummary::start(self : CalendarSummary) -> Date

    CalendarSummary::total_days

    source
    fn CalendarSummary::total_days(self : CalendarSummary) -> Int

    CalendarSummary::weekend_days

    source
    fn CalendarSummary::weekend_days(self : CalendarSummary) -> Int

    CalendarTimeline

    source
    pub struct CalendarTimeline {
      entries : Array[CalendarDayInfo]
    }

    Materialized daily calendar classifications for export and UI adapters.

    CalendarTimeline::between

    source
    fn CalendarTimeline::between(calendar~ : Calendar, start~ : Date, end~ : Date) -> Result[CalendarTimeline, TimelineError]

    Materialize a closed range of calendar classifications.

    CalendarTimeline::business_day_ratio

    source
    fn CalendarTimeline::business_day_ratio(self : CalendarTimeline) -> String

    Business-day share formatted to two decimal places.

    CalendarTimeline::business_days

    source

    CalendarTimeline::closure_count

    source
    fn CalendarTimeline::closure_count(self : CalendarTimeline) -> Int

    Number of non-business days in the materialized range.

    CalendarTimeline::closures

    source

    CalendarTimeline::days

    source

    CalendarTimeline::first

    source

    First materialized calendar entry.

    CalendarTimeline::last

    source

    Last materialized calendar entry.

    CalendarTimeline::to_csv

    source
    fn CalendarTimeline::to_csv(self : CalendarTimeline) -> String

    Export one row per date for simple downstream ingestion.

    CalendarTimeline::to_markdown

    source
    fn CalendarTimeline::to_markdown(self : CalendarTimeline) -> String

    Render the timeline as a compact Markdown table.

    CalendarValidationError

    source
    pub enum CalendarValidationError {
      CalendarMissingName
      CalendarMissingVersion
      CalendarInvalidRange
    } derive(Compare, Eq, 
    Debug    )

    CalendarVersion

    source
    pub struct CalendarVersion {
      name : String
      region : String
      version : String
      source : CalendarSource
      valid_from : Date
      valid_to : Date
    } derive(Compare, Eq, 
    Debug    )

    CalendarVersion::name

    source
    fn CalendarVersion::name(self : CalendarVersion) -> String

    CalendarVersion::new

    source
    fn CalendarVersion::new(name~ : String, region~ : String, version~ : String, source~ : CalendarSource, valid_from~ : Date, valid_to~ : Date) -> Result[CalendarVersion, CalendarVersionError]

    CalendarVersion::region

    source
    fn CalendarVersion::region(self : CalendarVersion) -> String

    CalendarVersion::source

    source

    CalendarVersion::valid_from

    source
    fn CalendarVersion::valid_from(self : CalendarVersion) -> Date

    CalendarVersion::valid_to

    source
    fn CalendarVersion::valid_to(self : CalendarVersion) -> Date

    CalendarVersion::version

    source
    fn CalendarVersion::version(self : CalendarVersion) -> String

    CalendarVersionError

    source
    pub enum CalendarVersionError {
      InvalidRange
      MissingVersionMetadata
      ObservationOutOfRange(Date)
    } derive(Compare, Eq, 
    Debug    )

    CatalogEntry

    source
    type CatalogEntry

    CatalogError

    source
    pub enum CatalogError {
      CatalogDuplicate(String)
      CatalogInvalid(CalendarValidationError)
    } derive(
    Debug    )

    CompletionError

    source
    pub enum CompletionError {
      CompletionBeforeStart
    } derive(Compare, Eq, 
    Debug    )

    ConstrainedDeadline

    source
    pub struct ConstrainedDeadline {
      start_date : Date
      rule : DateRule
      start_rule : StartDateRule
      calendar : Calendar
      extension : ExtensionPolicy
      constraints : Array[DeadlineConstraint]
    }

    ConstrainedDeadline::add_constraint

    source

    Add one validated constraint.

    ConstrainedDeadline::calculate

    source

    Calculate and enforce every constraint in insertion order.

    ConstrainedDeadline::new

    source
    fn ConstrainedDeadline::new(start_date~ : Date, rule~ : DateRule, start_rule~ : StartDateRule, calendar~ : Calendar, extension~ : ExtensionPolicy) -> ConstrainedDeadline

    Create a deadline with no constraints.

    ConstraintError

    source
    pub enum ConstraintError {
      ConstraintInvalidRange
      ConstraintViolation(String)
      ConstraintDeadlineFailure(DeadlineError)
    } derive(
    Debug    )

    CursorError

    source
    pub enum CursorError {
      CursorInvalidCount
      CursorCalendarFailure(CalendarError)
    } derive(
    Debug    )

    Date

    source
    pub struct Date {
      year : Int
      month : Int
      day : Int
    } derive(Compare, Eq, 
    Debug    )

    Date::add_days

    source
    fn Date::add_days(self : Date, count : Int) -> Date

    Date::add_months

    source
    fn Date::add_months(self : Date, count : Int) -> Date

    Date::add_years

    source
    fn Date::add_years(self : Date, count : Int) -> Date

    Date::from_ordinal

    source
    fn Date::from_ordinal(ordinal : Int) -> Result[Date, DateError]

    Restore a date from a zero-based ordinal.

    Date::new

    source
    fn Date::new(year~ : Int, month~ : Int, day~ : Int) -> Result[Date, DateError]

    Date::ordinal

    source
    fn Date::ordinal(self : Date) -> Int

    Return a zero-based ordinal suitable for compact storage.

    Date::parse

    source
    fn Date::parse(text : String) -> Result[Date, DateError]

    Date::to_string

    source
    fn Date::to_string(self : Date) -> String

    Date::try_add_days

    source
    fn Date::try_add_days(self : Date, count : Int) -> Result[Date, DateError]

    Date::try_add_months

    source
    fn Date::try_add_months(self : Date, count : Int) -> Result[Date, DateError]

    Date::try_add_years

    source
    fn Date::try_add_years(self : Date, count : Int) -> Result[Date, DateError]

    Date::weekday

    source
    fn Date::weekday(self : Date) -> Weekday

    DateError

    source
    pub enum DateError {
      OutOfRange
      InvalidYear
      InvalidMonth
      InvalidDay
      InvalidFormat
      InvalidNumber
    } derive(Compare, Eq, 
    Debug    )

    DateRange

    source
    pub struct DateRange {
      start : Date
      end : Date
    } derive(Compare, Eq, 
    Debug    )

    DateRange::business_days

    source
    fn DateRange::business_days(self : DateRange, calendar : Calendar) -> Int

    DateRange::calendar_days

    source
    fn DateRange::calendar_days(self : DateRange) -> Int

    DateRange::closed

    source
    fn DateRange::closed(start~ : Date, end~ : Date) -> Result[DateRange, DateRangeError]

    DateRange::contains

    source
    fn DateRange::contains(self : DateRange, date : Date) -> Bool

    DateRange::intersection

    source
    fn DateRange::intersection(self : DateRange, other : DateRange) -> Result[DateRange, DateRangeError]

    DateRange::overlaps

    source
    fn DateRange::overlaps(self : DateRange, other : DateRange) -> Bool

    DateRange::single

    source
    fn DateRange::single(date : Date) -> DateRange

    DateRange::union

    source
    fn DateRange::union(self : DateRange, other : DateRange) -> Result[DateRange, DateRangeError]

    DateRangeError

    source
    pub enum DateRangeError {
      Reversed
      OutOfRange
      NoIntersection
    } derive(Compare, Eq, 
    Debug    )

    DateRule

    source
    pub enum DateRule {
      CalendarDays(Int)
      BusinessDays(Int)
      Weeks(Int)
      Months(Int)
      Years(Int)
      Sequence(Array[DateRule])
    } derive(
    Debug    )

    DateRule::business_days

    source
    fn DateRule::business_days(count : Int) -> DateRule

    DateRule::calendar_days

    source
    fn DateRule::calendar_days(count : Int) -> DateRule

    DateRule::describe

    source
    fn DateRule::describe(self : DateRule) -> String

    Render a machine-readable compact rule description.

    DateRule::estimated_calendar_days

    source
    fn DateRule::estimated_calendar_days(self : DateRule) -> Int

    Return a conservative calendar-day estimate for planning UIs.

    DateRule::max_depth

    source
    fn DateRule::max_depth(self : DateRule) -> Int

    Return the maximum nested sequence depth, with a leaf at depth zero.

    DateRule::months

    source
    fn DateRule::months(count : Int) -> DateRule

    DateRule::node_count

    source
    fn DateRule::node_count(self : DateRule) -> Int

    Count the rule node and all nested sequence nodes.

    DateRule::parse

    source
    fn DateRule::parse(text : String) -> Result[DateRule, RuleParseError]

    Parse a stable comma-separated rule specification for library callers.

    DateRule::sequence

    source
    fn DateRule::sequence(rules : Array[DateRule]) -> DateRule

    DateRule::uses_business_days

    source
    fn DateRule::uses_business_days(self : DateRule) -> Bool

    Check whether a rule tree includes a business-day operation.

    DateRule::validate

    source
    fn DateRule::validate(self : DateRule) -> Result[Unit, RuleError]

    Validate every count in a nested rule.

    DateRule::weeks

    source
    fn DateRule::weeks(count : Int) -> DateRule

    DateRule::years

    source
    fn DateRule::years(count : Int) -> DateRule

    DateSeries

    source
    pub struct DateSeries {
      start : Date
      end : Date
      step : Int
    }

    DateSeries::collect

    source
    fn DateSeries::collect(self : DateSeries) -> Result[Array[Date], SeriesError]

    Materialize the inclusive date series.

    DateSeries::contains

    source
    fn DateSeries::contains(self : DateSeries, date : Date) -> Bool

    Check whether a date lies on a generated series point.

    DateSeries::new

    source
    fn DateSeries::new(start~ : Date, end~ : Date, step~ : Int) -> Result[DateSeries, SeriesError]

    Create an inclusive forward date series.

    Deadline

    source
    pub struct Deadline {
      start_date : Date
      rule : DateRule
      start_rule : StartDateRule
      calendar : Calendar
      extension : ExtensionPolicy
    } derive(
    Debug    )

    Deadline::calculate

    source
    fn Deadline::calculate(self : Deadline) -> Result[DeadlineResult, DeadlineError]

    Deadline::new

    source
    fn Deadline::new(start_date~ : Date, rule~ : DateRule, start_rule~ : StartDateRule, calendar~ : Calendar, extension~ : ExtensionPolicy) -> Deadline

    DeadlineConstraint

    source
    pub enum DeadlineConstraint {
      Within(Date, Date)
      MustBeBusinessDay
      NotCrossingYear
    } derive(Compare, Eq, 
    Debug    )

    DeadlineConstraint::must_be_business_day

    source
    fn DeadlineConstraint::must_be_business_day() -> DeadlineConstraint

    Require the calculated date to be a business day.

    DeadlineConstraint::not_crossing_year

    source
    fn DeadlineConstraint::not_crossing_year() -> DeadlineConstraint

    Reject a result that crosses a calendar year from its start.

    DeadlineConstraint::within

    source
    fn DeadlineConstraint::within(start~ : Date, end~ : Date) -> Result[DeadlineConstraint, ConstraintError]

    Create an inclusive date-window constraint.

    DeadlineError

    source
    pub enum DeadlineError {
      NegativeRuleCount
      CalendarFailure(CalendarError)
      DateFailure(DateError)
    } derive(
    Debug    )

    DeadlineForecast

    source
    pub struct DeadlineForecast {
      start : Date
      unit : ForecastUnit
      start_rule : StartDateRule
      calendar : Calendar
      extension : ExtensionPolicy
    }

    DeadlineForecast::calculate

    source
    fn DeadlineForecast::calculate(self : DeadlineForecast, counts : Array[Int]) -> Result[ForecastResult, ForecastError]

    Evaluate each requested count without reordering the input.

    DeadlineForecast::new

    source
    fn DeadlineForecast::new(start~ : Date, unit~ : ForecastUnit, start_rule~ : StartDateRule, calendar~ : Calendar, extension~ : ExtensionPolicy) -> DeadlineForecast

    Create a forecast for one rule family.

    DeadlineLedger

    source
    pub struct DeadlineLedger {
      records : Array[DeadlineRecord]
    }

    DeadlineLedger::add

    source

    Add a record with a unique application identifier.

    DeadlineLedger::completed

    source
    fn DeadlineLedger::completed(self : DeadlineLedger, as_of : Date) -> Array[String]

    Return identifiers with completion evidence.

    DeadlineLedger::due

    source
    fn DeadlineLedger::due(self : DeadlineLedger, as_of : Date) -> Array[String]

    Return identifiers due on the supplied date.

    DeadlineLedger::find

    source
    fn DeadlineLedger::find(self : DeadlineLedger, id : String) -> DeadlineRecord?

    Find a record by application identifier.

    DeadlineLedger::new

    source

    Create an empty in-memory deadline ledger.

    DeadlineLedger::overdue

    source
    fn DeadlineLedger::overdue(self : DeadlineLedger, as_of : Date) -> Array[String]

    Return identifiers past due and not completed.

    DeadlineMatrix

    source
    pub struct DeadlineMatrix {
      start : Date
      rule : DateRule
      start_rule : StartDateRule
      extension : ExtensionPolicy
      scenarios : Array[MatrixScenario]
    }

    DeadlineMatrix::add_calendar

    source
    fn DeadlineMatrix::add_calendar(self : DeadlineMatrix, name : String, calendar : Calendar) -> Result[DeadlineMatrix, MatrixError]

    Add a named calendar scenario.

    DeadlineMatrix::calculate

    source
    fn DeadlineMatrix::calculate(self : DeadlineMatrix) -> Result[MatrixResult, MatrixError]

    Calculate scenarios in insertion order.

    DeadlineMatrix::new

    source
    fn DeadlineMatrix::new(start~ : Date, rule~ : DateRule, start_rule~ : StartDateRule, extension~ : ExtensionPolicy) -> DeadlineMatrix

    Start a cross-calendar deadline comparison.

    DeadlinePlan

    source
    pub struct DeadlinePlan {
      start_date : Date
      stages : Array[PlanStage]
    } derive(
    Debug    )

    DeadlinePlan::add_stage

    source
    fn DeadlinePlan::add_stage(self : DeadlinePlan, label~ : String, rule~ : DateRule, start_rule~ : StartDateRule, calendar~ : Calendar, extension~ : ExtensionPolicy, start_source? : StageStartSource, suspension? : SuspensionSet) -> Result[DeadlinePlan, PlanError]

    DeadlinePlan::calculate

    source
    fn DeadlinePlan::calculate(self : DeadlinePlan) -> Result[PlanResult, PlanError]

    DeadlinePlan::new

    source
    fn DeadlinePlan::new(start_date~ : Date) -> DeadlinePlan

    DeadlinePlan::stage

    source
    fn DeadlinePlan::stage(self : DeadlinePlan, index : Int) -> Result[PlanStage, PlanError]

    DeadlinePlan::stage_count

    source
    fn DeadlinePlan::stage_count(self : DeadlinePlan) -> Int

    DeadlinePlan::stages

    source
    fn DeadlinePlan::stages(self : DeadlinePlan) -> Array[PlanStage]

    DeadlinePlan::start_date

    source
    fn DeadlinePlan::start_date(self : DeadlinePlan) -> Date

    DeadlineRecord

    source
    pub struct DeadlineRecord {
      id : String
      result : DeadlineResult
      completed_on : Date?
    }

    DeadlineRecord::complete

    source
    fn DeadlineRecord::complete(self : DeadlineRecord, completed_on : Date) -> Result[DeadlineRecord, CompletionError]

    Record completion evidence, rejecting impossible pre-start evidence.

    DeadlineRecord::id

    source
    fn DeadlineRecord::id(self : DeadlineRecord) -> String

    Return the business identifier of the record.

    DeadlineRecord::new

    source
    fn DeadlineRecord::new(id : String, result : DeadlineResult) -> DeadlineRecord

    Create a trackable deadline record.

    DeadlineRecord::result

    source

    Return the tracked deadline result.

    DeadlineRecord::status

    source
    fn DeadlineRecord::status(self : DeadlineRecord, as_of : Date) -> DeadlineStatus

    Classify a record, prioritizing completion evidence.

    DeadlineRequest

    source
    pub struct DeadlineRequest {
      id : String
      start : Date
      rule : DateRule
      start_rule : StartDateRule
      calendar : Calendar
      extension : ExtensionPolicy
    }

    A validated request boundary for application integrations.

    DeadlineRequest::new

    source
    fn DeadlineRequest::new(id~ : String, start~ : Date, rule~ : DateRule, start_rule~ : StartDateRule, calendar~ : Calendar, extension~ : ExtensionPolicy) -> DeadlineRequest

    Create an application-facing deadline request.

    DeadlineResult

    source
    pub struct DeadlineResult {
      start : Date
      rule : DateRule
      original : Date
      adjusted : Date
      adjustment_count : Int
      crossed_month : Bool
      crossed_year : Bool
      steps : Array[CalculationStep]
      explanation : String
    } derive(
    Debug    )

    DeadlineResult::adjusted_date

    source
    fn DeadlineResult::adjusted_date(self : DeadlineResult) -> Date

    DeadlineResult::adjustment_count

    source
    fn DeadlineResult::adjustment_count(self : DeadlineResult) -> Int

    DeadlineResult::count_kind

    source
    fn DeadlineResult::count_kind(self : DeadlineResult, kind : StepKind) -> Int

    Count steps with a selected semantic kind.

    DeadlineResult::crossed_month

    source
    fn DeadlineResult::crossed_month(self : DeadlineResult) -> Bool

    DeadlineResult::crossed_year

    source
    fn DeadlineResult::crossed_year(self : DeadlineResult) -> Bool

    DeadlineResult::explain

    source
    fn DeadlineResult::explain(self : DeadlineResult) -> String

    DeadlineResult::has_extension

    source
    fn DeadlineResult::has_extension(self : DeadlineResult) -> Bool

    Whether the result contains an extension step.

    DeadlineResult::original_date

    source
    fn DeadlineResult::original_date(self : DeadlineResult) -> Date

    DeadlineResult::rule

    source

    DeadlineResult::start_date

    source
    fn DeadlineResult::start_date(self : DeadlineResult) -> Date

    DeadlineResult::status

    source
    fn DeadlineResult::status(self : DeadlineResult, as_of : Date) -> DeadlineStatus

    Classify the uncompleted state of a deadline at a given date.

    DeadlineResult::step_count

    source
    fn DeadlineResult::step_count(self : DeadlineResult) -> Int

    Number of recorded calculation steps.

    DeadlineResult::step_notes

    source
    fn DeadlineResult::step_notes(self : DeadlineResult) -> Array[String]

    Return one note per recorded calculation step.

    DeadlineResult::steps

    source

    DeadlineResult::summary

    source
    fn DeadlineResult::summary(self : DeadlineResult) -> String

    Compact start-to-adjusted summary for logs and table rows.

    DeadlineService

    source
    pub enum DeadlineService {
    }

    DeadlineService::evaluate

    source
    fn DeadlineService::evaluate(request : DeadlineRequest) -> Result[DeadlineRecord, ServiceError]

    Validate and calculate one request into a trackable record.

    DeadlineStatus

    source
    pub enum DeadlineStatus {
      Pending
      DueToday
      Overdue
      Completed
    } derive(Compare, Eq, 
    Debug    )

    DeadlineStatus::completed

    source
    fn DeadlineStatus::completed() -> DeadlineStatus

    DeadlineStatus::due_today

    source
    fn DeadlineStatus::due_today() -> DeadlineStatus

    DeadlineStatus::overdue

    source

    DeadlineStatus::pending

    source

    DeadlineStatus::to_string

    source
    fn DeadlineStatus::to_string(self : DeadlineStatus) -> String

    DeadlineWindow

    source
    pub struct DeadlineWindow {
      start : Date
      end : Date
    }

    A closed interval used for SLA windows and reporting periods.

    DeadlineWindow::business_days

    source
    fn DeadlineWindow::business_days(self : DeadlineWindow, calendar : Calendar) -> Int

    Number of business days in the window.

    DeadlineWindow::calendar_days

    source
    fn DeadlineWindow::calendar_days(self : DeadlineWindow) -> Int

    Number of calendar days in the window.

    DeadlineWindow::contains

    source
    fn DeadlineWindow::contains(self : DeadlineWindow, date : Date) -> Bool

    Check inclusive membership.

    DeadlineWindow::end

    source

    Inclusive last date of the window.

    DeadlineWindow::intersection

    source
    fn DeadlineWindow::intersection(self : DeadlineWindow, other : DeadlineWindow) -> Result[DeadlineWindow, WindowError]

    Return the shared closed interval.

    DeadlineWindow::intersects

    source
    fn DeadlineWindow::intersects(self : DeadlineWindow, other : DeadlineWindow) -> Bool

    Check whether two windows share at least one date.

    DeadlineWindow::new

    source
    fn DeadlineWindow::new(start~ : Date, end~ : Date) -> Result[DeadlineWindow, WindowError]

    DeadlineWindow::shift

    source
    fn DeadlineWindow::shift(self : DeadlineWindow, offset : Int) -> Result[DeadlineWindow, WindowError]

    Move the whole window by a calendar-day offset.

    DeadlineWindow::start

    source
    fn DeadlineWindow::start(self : DeadlineWindow) -> Date

    Inclusive first date of the window.

    EventContext

    source
    pub struct EventContext {
      entries : Array[EventEntry]
    }

    An immutable collection of named event definitions.

    EventContext::insert

    source
    fn EventContext::insert(self : EventContext, name : String, spec : EventSpec) -> Result[EventContext, EventError]

    Add a definition without mutating the original context.

    EventContext::new

    source

    Create an empty event context.

    EventContext::resolve

    source
    fn EventContext::resolve(self : EventContext, name : String) -> Result[Date, EventError]

    Resolve a named event and all of its dependencies.

    EventDeadline

    source
    pub struct EventDeadline {
      event : String
      rule : DateRule
      start_rule : StartDateRule
      calendar : Calendar
      extension : ExtensionPolicy
    }

    A deadline whose start date is resolved from an event context.

    EventDeadline::calculate

    source
    fn EventDeadline::calculate(self : EventDeadline, context : EventContext) -> Result[DeadlineResult, EventDeadlineError]

    Resolve the event and run the standard deadline engine.

    EventDeadline::new

    source
    fn EventDeadline::new(event~ : String, rule~ : DateRule, start_rule~ : StartDateRule, calendar~ : Calendar, extension~ : ExtensionPolicy) -> EventDeadline

    Create a deadline that starts at a named event.

    EventDeadlineError

    source
    pub enum EventDeadlineError {
      Event(EventError)
      Deadline(DeadlineError)
    } derive(
    Debug    )

    EventEntry

    source
    type EventEntry

    EventError

    source
    pub enum EventError {
      EventDuplicate(String)
      EventMissing(String)
      EventCycle(String)
      EventNegativeOffset(String)
      EventDateFailure(DateError)
    } derive(Compare, Eq, 
    Debug    )

    Errors produced while resolving named events.

    EventSpec

    source
    pub enum EventSpec {
      Fixed(Date)
      After(String, Int)
    } derive(Compare, Eq, 
    Debug    )

    A named date that can be used as the start of a deadline workflow.

    EventSpec::after

    source
    fn EventSpec::after(name : String, offset : Int) -> EventSpec

    Create an event offset by calendar days from another event.

    EventSpec::fixed

    source
    fn EventSpec::fixed(date : Date) -> EventSpec

    Create a fixed-date event definition.

    ExtensionPolicy

    source
    pub enum ExtensionPolicy {
      NoExtension
      Following
      ModifiedFollowing
      Preceding
    } derive(Compare, Eq, 
    Debug    )

    ExtensionPolicy::following

    source
    fn ExtensionPolicy::following() -> ExtensionPolicy

    ExtensionPolicy::modified_following

    source
    fn ExtensionPolicy::modified_following() -> ExtensionPolicy

    ExtensionPolicy::no_extension

    source
    fn ExtensionPolicy::no_extension() -> ExtensionPolicy

    ExtensionPolicy::preceding

    source
    fn ExtensionPolicy::preceding() -> ExtensionPolicy

    ForecastError

    source
    pub enum ForecastError {
      ForecastEmpty
      ForecastNegativeCount
      ForecastDeadlineFailure(DeadlineError)
    } derive(
    Debug    )

    ForecastResult

    source
    pub struct ForecastResult {
      counts : Array[Int]
      dates : Array[Date]
    }

    ForecastResult::counts

    source
    fn ForecastResult::counts(self : ForecastResult) -> Array[Int]

    ForecastResult::dates

    source
    fn ForecastResult::dates(self : ForecastResult) -> Array[Date]

    ForecastResult::get

    source
    fn ForecastResult::get(self : ForecastResult, count : Int) -> Date?

    ForecastUnit

    source
    pub enum ForecastUnit {
      CalendarDays
      BusinessDays
      Weeks
      Months
      Years
    } derive(Compare, Eq, 
    Debug    )

    ForecastUnit::business_days

    source
    fn ForecastUnit::business_days() -> ForecastUnit

    ForecastUnit::calendar_days

    source
    fn ForecastUnit::calendar_days() -> ForecastUnit

    ForecastUnit::months

    source
    fn ForecastUnit::months() -> ForecastUnit

    ForecastUnit::weeks

    source
    fn ForecastUnit::weeks() -> ForecastUnit

    ForecastUnit::years

    source
    fn ForecastUnit::years() -> ForecastUnit

    LedgerError

    source
    pub enum LedgerError {
      LedgerDuplicate(String)
    } derive(Compare, Eq, 
    Debug    )

    MatrixEntry

    source
    type MatrixEntry

    MatrixError

    source
    pub enum MatrixError {
      MatrixDuplicate(String)
      MatrixEmpty
      MatrixMissing(String)
      MatrixDeadlineFailure(DeadlineError)
    } derive(
    Debug    )

    MatrixResult

    source
    pub struct MatrixResult {
      entries : Array[MatrixEntry]
    }

    MatrixResult::delta

    source
    fn MatrixResult::delta(self : MatrixResult, left : String, right : String) -> Result[Int, MatrixError]

    Difference in adjusted calendar days between two scenarios.

    MatrixResult::get

    source
    fn MatrixResult::get(self : MatrixResult, name : String) -> DeadlineResult?

    Look up one scenario result.

    MatrixResult::ordered

    source
    fn MatrixResult::ordered(self : MatrixResult) -> Array[String]

    Return scenario names in calculation order.

    MatrixScenario

    source
    type MatrixScenario

    ObligationSchedule

    source
    pub struct ObligationSchedule {
      start : Date
      rule : ScheduleRule
      calendar : Calendar
      extension : ExtensionPolicy
    }

    ObligationSchedule::new

    source
    fn ObligationSchedule::new(start~ : Date, rule~ : ScheduleRule, calendar~ : Calendar, extension~ : ExtensionPolicy) -> Result[ObligationSchedule, ScheduleError]

    Create a recurring obligation schedule.

    ObligationSchedule::occurrences

    source
    fn ObligationSchedule::occurrences(self : ObligationSchedule, count : Int) -> Result[Array[Date], ScheduleError]

    Generate a fixed number of occurrences, including the start anchor.

    PlanError

    source
    pub enum PlanError {
      EmptyStageLabel
      StageIndexOutOfRange(Int)
      StageLabelNotFound(String)
      StageDeadlineFailure(Int, String, DeadlineError)
      StageSuspensionFailure(Int, String, SuspensionError)
    } derive(
    Debug    )

    PlanResult

    source
    pub struct PlanResult {
      start_date : Date
      stages : Array[PlanStageResult]
      final_original : Date
      final_adjusted : Date
    } derive(
    Debug    )

    PlanResult::final_adjusted_date

    source
    fn PlanResult::final_adjusted_date(self : PlanResult) -> Date

    PlanResult::final_original_date

    source
    fn PlanResult::final_original_date(self : PlanResult) -> Date

    PlanResult::stage

    source
    fn PlanResult::stage(self : PlanResult, index : Int) -> Result[PlanStageResult, PlanError]

    PlanResult::stage_count

    source
    fn PlanResult::stage_count(self : PlanResult) -> Int

    PlanResult::stage_named

    source
    fn PlanResult::stage_named(self : PlanResult, label : String) -> Result[PlanStageResult, PlanError]

    PlanResult::stages

    source

    PlanResult::start_date

    source
    fn PlanResult::start_date(self : PlanResult) -> Date

    PlanStage

    source
    pub struct PlanStage {
      label : String
      rule : DateRule
      start_rule : StartDateRule
      calendar : Calendar
      extension : ExtensionPolicy
      start_source : StageStartSource
      suspension : SuspensionSet?
    } derive(
    Debug    )

    PlanStage::calendar

    source
    fn PlanStage::calendar(self : PlanStage) -> Calendar

    PlanStage::extension

    source
    fn PlanStage::extension(self : PlanStage) -> ExtensionPolicy

    PlanStage::label

    source
    fn PlanStage::label(self : PlanStage) -> String

    PlanStage::new

    source
    fn PlanStage::new(label~ : String, rule~ : DateRule, start_rule~ : StartDateRule, calendar~ : Calendar, extension~ : ExtensionPolicy, start_source? : StageStartSource, suspension? : SuspensionSet) -> Result[PlanStage, PlanError]

    PlanStage::rule

    source
    fn PlanStage::rule(self : PlanStage) -> DateRule

    PlanStage::start_rule

    source
    fn PlanStage::start_rule(self : PlanStage) -> StartDateRule

    PlanStage::start_source

    source
    fn PlanStage::start_source(self : PlanStage) -> StageStartSource

    PlanStage::suspension

    source
    fn PlanStage::suspension(self : PlanStage) -> SuspensionSet?

    PlanStageResult

    source
    pub struct PlanStageResult {
      index : Int
      label : String
      result : DeadlineResult
    } derive(
    Debug    )

    PlanStageResult::adjusted_date

    source
    fn PlanStageResult::adjusted_date(self : PlanStageResult) -> Date

    PlanStageResult::deadline_result

    source
    fn PlanStageResult::deadline_result(self : PlanStageResult) -> DeadlineResult

    PlanStageResult::index

    source
    fn PlanStageResult::index(self : PlanStageResult) -> Int

    PlanStageResult::label

    source
    fn PlanStageResult::label(self : PlanStageResult) -> String

    PlanStageResult::original_date

    source
    fn PlanStageResult::original_date(self : PlanStageResult) -> Date

    PlanStageResult::start_date

    source
    fn PlanStageResult::start_date(self : PlanStageResult) -> Date

    ReminderError

    source
    pub enum ReminderError {
      ReminderNegativeOffset
      ReminderDuplicateOffset
      ReminderDateFailure
    } derive(
    Debug    )

    ReminderPlan

    source
    pub struct ReminderPlan {
      result : DeadlineResult
      calendar : Calendar
      rules : Array[ReminderRule]
    }

    ReminderPlan::add

    source

    Add a unique offset rule.

    ReminderPlan::calculate

    source
    fn ReminderPlan::calculate(self : ReminderPlan) -> Result[Array[Date], ReminderError]

    Calculate reminders in configured order.

    ReminderPlan::new

    source
    fn ReminderPlan::new(result : DeadlineResult, calendar : Calendar) -> ReminderPlan

    Create a reminder plan for one calculated deadline.

    ReminderRule

    source
    pub enum ReminderRule {
      CalendarDaysBefore(Int)
      BusinessDaysBefore(Int)
    } derive(Compare, Eq, 
    Debug    )

    ReminderRule::business_days_before

    source
    fn ReminderRule::business_days_before(count : Int) -> Result[ReminderRule, ReminderError]

    Create a business-day reminder rule.

    ReminderRule::calendar_days_before

    source
    fn ReminderRule::calendar_days_before(count : Int) -> Result[ReminderRule, ReminderError]

    Create a calendar-day reminder rule.

    RuleError

    source
    pub enum RuleError {
      RuleNegativeCount
    } derive(Compare, Eq, 
    Debug    )

    RuleParseError

    source
    pub enum RuleParseError {
      RuleInvalidFormat
      RuleInvalidNumber(String)
      RuleUnknownUnit(String)
      RuleParseNegativeCount
    } derive(Compare, Eq, 
    Debug    )

    ScheduleError

    source
    pub enum ScheduleError {
      ScheduleInvalidInterval
      ScheduleInvalidCount
      ScheduleDateFailure(DateError)
      ScheduleCalendarFailure(CalendarError)
    } derive(
    Debug    )

    ScheduleRule

    source
    pub enum ScheduleRule {
      EveryCalendarDays(Int)
      EveryBusinessDays(Int)
      WeeklyOn(Weekday, Int)
      MonthlyOn(Int, Int)
    } derive(Compare, Eq, 
    Debug    )

    ScheduleRule::every_business_days

    source
    fn ScheduleRule::every_business_days(interval : Int) -> ScheduleRule

    ScheduleRule::every_calendar_days

    source
    fn ScheduleRule::every_calendar_days(interval : Int) -> ScheduleRule

    ScheduleRule::monthly_on

    source
    fn ScheduleRule::monthly_on(day~ : Int, interval~ : Int) -> ScheduleRule

    ScheduleRule::weekly_on

    source
    fn ScheduleRule::weekly_on(weekday~ : Weekday, interval~ : Int) -> ScheduleRule

    SeriesError

    source
    pub enum SeriesError {
      SeriesInvalidStep
      SeriesReversed
      SeriesOutOfRange
    } derive(Compare, Eq, 
    Debug    )

    ServiceError

    source
    pub enum ServiceError {
      ServiceInvalidId
      ServiceInvalidRule(RuleError)
      ServiceDeadlineFailure(DeadlineError)
    } derive(
    Debug    )

    StageStartSource

    source
    pub enum StageStartSource {
      PreviousAdjusted
      PreviousOriginal
    } derive(Compare, Eq, 
    Debug    )

    StageStartSource::previous_adjusted

    source
    fn StageStartSource::previous_adjusted() -> StageStartSource

    StageStartSource::previous_original

    source
    fn StageStartSource::previous_original() -> StageStartSource

    StartDateRule

    source
    pub enum StartDateRule {
      Include
      Exclude
    } derive(Compare, Eq, 
    Debug    )

    StartDateRule::exclude

    source
    fn StartDateRule::exclude() -> StartDateRule

    StartDateRule::including_start

    source
    fn StartDateRule::including_start() -> StartDateRule

    StepKind

    source
    pub enum StepKind {
      Start
      Count
      Extension
      Complete
    } derive(Compare, Eq, 
    Debug    )

    StepKind::complete

    source
    fn StepKind::complete() -> StepKind

    StepKind::count

    source
    fn StepKind::count() -> StepKind

    StepKind::extension

    source
    fn StepKind::extension() -> StepKind

    StepKind::start

    source
    fn StepKind::start() -> StepKind

    SuspensionError

    source
    pub enum SuspensionError {
      Reversed
      OutOfRange
      Aborted
    } derive(Compare, Eq, 
    Debug    )

    SuspensionPeriod

    source
    pub struct SuspensionPeriod {
      start : Date
      end : Date
    } derive(Compare, Eq, 
    Debug    )

    SuspensionPeriod::end

    source

    SuspensionPeriod::new

    source
    fn SuspensionPeriod::new(start~ : Date, end~ : Date) -> Result[SuspensionPeriod, SuspensionError]

    SuspensionPeriod::start

    source

    SuspensionPolicy

    source
    pub enum SuspensionPolicy {
      PauseInclusive
      PauseExclusive
    } derive(Compare, Eq, 
    Debug    )

    SuspensionPolicy::pause_exclusive

    source
    fn SuspensionPolicy::pause_exclusive() -> SuspensionPolicy

    SuspensionPolicy::pause_inclusive

    source
    fn SuspensionPolicy::pause_inclusive() -> SuspensionPolicy

    SuspensionSet

    source
    pub struct SuspensionSet {
      periods : Array[SuspensionPeriod]
      policy : SuspensionPolicy
      abort_on : Date?
    } derive(
    Debug    )

    SuspensionSet::abort_on

    source
    fn SuspensionSet::abort_on(self : SuspensionSet) -> Date?

    SuspensionSet::business_days

    source
    fn SuspensionSet::business_days(self : SuspensionSet, calendar : Calendar) -> Int

    SuspensionSet::calendar_days

    source
    fn SuspensionSet::calendar_days(self : SuspensionSet) -> Int

    SuspensionSet::new

    source
    fn SuspensionSet::new(periods~ : Array[SuspensionPeriod], policy? : SuspensionPolicy, abort_on? : Date) -> SuspensionSet

    SuspensionSet::normalize

    source
    fn SuspensionSet::normalize(self : SuspensionSet) -> SuspensionSet

    SuspensionSet::periods

    source

    SuspensionSet::policy

    source

    TimelineError

    source
    pub enum TimelineError {
      TimelineReversed
      TimelineOutOfRange
    } derive(Compare, Eq, 
    Debug    )

    Weekday

    source
    pub enum Weekday {
      Monday
      Tuesday
      Wednesday
      Thursday
      Friday
      Saturday
      Sunday
    } derive(Compare, Eq, 
    Debug    )

    Weekday::friday

    source
    fn Weekday::friday() -> Weekday

    Construct a Friday weekday value for recurring schedules.

    Weekday::is_monday

    source
    fn Weekday::is_monday(self : Weekday) -> Bool

    Weekday::monday

    source
    fn Weekday::monday() -> Weekday

    Construct a Monday weekday value for recurring schedules.

    Weekday::saturday

    source
    fn Weekday::saturday() -> Weekday

    Construct a Saturday weekday value for recurring schedules.

    Weekday::sunday

    source
    fn Weekday::sunday() -> Weekday

    Construct a Sunday weekday value for recurring schedules.

    Weekday::thursday

    source
    fn Weekday::thursday() -> Weekday

    Construct a Thursday weekday value for recurring schedules.

    Weekday::to_string

    source
    fn Weekday::to_string(self : Weekday) -> String

    Weekday::tuesday

    source
    fn Weekday::tuesday() -> Weekday

    Construct a Tuesday weekday value for recurring schedules.

    Weekday::wednesday

    source
    fn Weekday::wednesday() -> Weekday

    Construct a Wednesday weekday value for recurring schedules.

    WeekendPolicy

    source
    pub enum WeekendPolicy {
      SaturdaySunday
      FridaySaturday
      NoWeekend
    } derive(Compare, Eq, 
    Debug    )

    WeekendPolicy::friday_saturday

    source
    fn WeekendPolicy::friday_saturday() -> WeekendPolicy

    WeekendPolicy::is_weekend

    source
    fn WeekendPolicy::is_weekend(self : WeekendPolicy, weekday : Weekday) -> Bool

    WeekendPolicy::no_weekend

    source
    fn WeekendPolicy::no_weekend() -> WeekendPolicy

    WeekendPolicy::saturday_sunday

    source
    fn WeekendPolicy::saturday_sunday() -> WeekendPolicy

    WindowError

    source
    pub enum WindowError {
      WindowReversed
      WindowOutOfRange
    } derive(Compare, Eq, 
    Debug    )

    Source Files

    Powered by MoonBit

    Site sourceReport issueModulesSkillsCLIBuild queueStatistics

    © 2026 mooncakes.io