pub(all) struct Calendar {
  version : String?
  prodid : String?
  events : Array[Event]
  tasks : Array[Task]
  freebusy : Array[FreeBusy]
  properties : Array[IcsProperty]
} derive(
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct CalendarSummary {
  event_count : Int
  recurring_event_count : Int
  all_day_event_count : Int
  task_count : Int
  open_task_count : Int
  completed_task_count : Int
  blocked_time_count : Int
  blocked_period_count : Int
  earliest : DateTime?
  latest : DateTime?
  diagnostics : Array[Diagnostic]
} derive(
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct DateTime {
  year : Int
  month : Int
  day : Int
  hour : Int
  minute : Int
  second : Int
  is_date : Bool
  is_utc : Bool
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct Diagnostic {
  code : String
  message : String
  severity : String
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct Duration {
  negative : Bool
  weeks : Int
  days : Int
  hours : Int
  minutes : Int
  seconds : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct Event {
  uid : String
  start : DateTime
  end : DateTime?
  summary : String
  description : String?
  location : String?
  status : String?
  url : String?
  categories : Array[String]
  created : DateTime?
  last_modified : DateTime?
  sequence : Int?
  rrule : RRule?
  duration : Duration?
  rdate : Array[DateTime]
  exdate : Array[DateTime]
  raw : Array[IcsProperty]
} derive(
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct FreeBusy {
  uid : String?
  start : DateTime?
  end : DateTime?
  dtstamp : DateTime?
  organizer : String?
  attendees : Array[String]
  comments : Array[String]
  url : String?
  periods : Array[FreeBusyPeriod]
  raw : Array[IcsProperty]
} derive(
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct FreeBusyPeriod {
  start : DateTime
  end : DateTime
  busy_type : String
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct FreeBusySummary {
  component_count : Int
  period_count : Int
  busy_period_count : Int
  tentative_period_count : Int
  unavailable_period_count : Int
  free_period_count : Int
  earliest_start : DateTime?
  latest_end : DateTime?
} derive(
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum Frequency {
  Daily
  Weekly
  Monthly
  Yearly
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct IcsProperty {
  name : String
  params : Map[String, String]
  value : String
  line : Int
} derive(
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum MoonCalError {
  InvalidLine(line~ : Int, message~ : String)
  InvalidProperty(line~ : Int, name~ : String, message~ : String)
  InvalidDateTime(value~ : String)
  InvalidRRule(value~ : String, message~ : String)
  InvalidCalendar(message~ : String)
  MissingEventField(field~ : String)
  MissingTaskField(field~ : String)
  UnsupportedFeature(feature~ : String)
  LimitExceeded(limit~ : Int)
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct Occurrence {
  uid : String
  start : DateTime
  end : DateTime?
  summary : String
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct RRule {
  freq : Frequency
  interval : Int
  count : Int?
  until : DateTime?
  byday : Array[Weekday]
  bymonthday : Array[Int]
  bymonth : Array[Int]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct Task {
  uid : String
  start : DateTime?
  due : DateTime?
  completed : DateTime?
  created : DateTime?
  last_modified : DateTime?
  summary : String
  description : String?
  status : String?
  priority : Int?
  percent_complete : Int?
  categories : Array[String]
  url : String?
  related_to : Array[String]
  raw : Array[IcsProperty]
} derive(
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct TaskSummary {
  task_count : Int
  open_task_count : Int
  completed_task_count : Int
  in_process_task_count : Int
  cancelled_task_count : Int
  high_priority_task_count : Int
  due_task_count : Int
  earliest_due : DateTime?
  latest_due : DateTime?
} derive(
@moonbitlang/core/debug.Debug
Debug)

pub(all) enum Weekday {
  MO
  TU
  WE
  TH
  FR
  SA
  SU
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

fn analyze(input : String) -> Result[CalendarSummary, MoonCalError]

fn busy_periods_between(calendar : Calendar, from : DateTime, until : DateTime) -> Array[FreeBusyPeriod]

fn calendar_to_ics(calendar : Calendar) -> String

fn calendar_to_json(calendar : Calendar) -> String

fn cancelled_tasks(calendar : Calendar) -> Array[Task]

fn completed_tasks(calendar : Calendar) -> Array[Task]

fn days_in_month(year : Int, month : Int) -> Int

fn error_to_text(err : MoonCalError) -> String

fn escape_ics_text(value : String) -> String

fn escape_json(value : String) -> String

fn event_effective_end(event : Event) -> DateTime?

fn event_is_recurring(event : Event) -> Bool

fn event_overlaps(event : Event, from : DateTime, until : DateTime) -> Bool

fn event_to_ics(event : Event) -> String

fn event_to_json(event : Event) -> String

fn events_between(calendar : Calendar, from : DateTime, until : DateTime) -> Array[Event]

fn expand_calendar_between(calendar : Calendar, from : DateTime, until : DateTime, limit? : Int) -> Result[Array[Occurrence], MoonCalError]

fn expand_event_between(event : Event, from : DateTime, until : DateTime, limit? : Int) -> Result[Array[Occurrence], MoonCalError]

fn find_event(calendar : Calendar, uid : String) -> Event?

fn find_task(calendar : Calendar, uid : String) -> Task?

fn free_periods_between(calendar : Calendar, from : DateTime, until : DateTime) -> Array[FreeBusyPeriod]

fn freebusy_is_busy_type(period : FreeBusyPeriod) -> Bool

fn freebusy_period_contains(period : FreeBusyPeriod, moment : DateTime) -> Bool

fn freebusy_period_overlaps(period : FreeBusyPeriod, from : DateTime, until : DateTime) -> Bool

fn freebusy_period_to_ics(period : FreeBusyPeriod) -> String

fn freebusy_period_to_json(period : FreeBusyPeriod) -> String

fn freebusy_periods_between(calendar : Calendar, from : DateTime, until : DateTime) -> Array[FreeBusyPeriod]

fn freebusy_summary_to_json(summary : FreeBusySummary) -> String

fn freebusy_to_ics(item : FreeBusy) -> String

fn freebusy_to_json(item : FreeBusy) -> String

fn frequency_to_string(freq : Frequency) -> String

fn high_priority_tasks(calendar : Calendar) -> Array[Task]

fn is_leap_year(year : Int) -> Bool

fn is_valid_date(year : Int, month : Int, day : Int) -> Bool

fn next_busy_periods(calendar : Calendar, after : DateTime, limit? : Int) -> Array[FreeBusyPeriod]

fn next_occurrences(calendar : Calendar, after : DateTime, limit? : Int) -> Result[Array[Occurrence], MoonCalError]

fn occurrences_between(calendar : Calendar, from : DateTime, until : DateTime, limit? : Int) -> Result[Array[Occurrence], MoonCalError]

fn occurrences_on_date(calendar : Calendar, date : DateTime, limit? : Int) -> Result[Array[Occurrence], MoonCalError]

fn occurrences_to_json(items : Array[Occurrence]) -> String

fn open_tasks(calendar : Calendar) -> Array[Task]

fn overdue_tasks(calendar : Calendar, as_of : DateTime) -> Array[Task]

let package_name : String

fn parse(input : String) -> Result[Calendar, MoonCalError]

fn parse_calendar(input : String) -> Result[Calendar, MoonCalError]

fn parse_datetime(value : String, is_date_hint? : Bool) -> Result[DateTime, MoonCalError]

fn parse_duration(input : String) -> Result[Duration, MoonCalError]

fn parse_event(props : Array[IcsProperty]) -> Result[Event, MoonCalError]

fn parse_freebusy(props : Array[IcsProperty]) -> Result[FreeBusy, MoonCalError]

fn parse_frequency(value : String) -> Frequency?

fn parse_properties(input : String) -> Result[Array[IcsProperty], MoonCalError]

fn parse_property_line(line : String, line_number : Int) -> Result[IcsProperty, MoonCalError]

fn parse_rrule(input : String) -> Result[RRule, MoonCalError]

fn parse_rule(input : String) -> Result[RRule, MoonCalError]

fn parse_task(props : Array[IcsProperty]) -> Result[Task, MoonCalError]

fn parse_weekday(value : String) -> Weekday?

fn rrule_to_ics(rule : RRule) -> String

let sample_ics : String

fn summarize(calendar : Calendar) -> CalendarSummary

fn summarize_freebusy(calendar : Calendar) -> FreeBusySummary

fn summarize_tasks(calendar : Calendar) -> TaskSummary

fn summary_to_json(summary : CalendarSummary) -> String

fn summary_to_text(summary : CalendarSummary) -> String

fn task_due_between(task : Task, from : DateTime, until : DateTime) -> Bool

fn task_due_on_date(task : Task, date : DateTime) -> Bool

fn task_is_cancelled(task : Task) -> Bool

fn task_is_completed(task : Task) -> Bool

fn task_is_in_process(task : Task) -> Bool

fn task_is_open(task : Task) -> Bool

fn task_is_overdue(task : Task, as_of : DateTime) -> Bool

fn task_summary_to_json(summary : TaskSummary) -> String

fn task_to_ics(task : Task) -> String

fn task_to_json(task : Task) -> String

fn tasks_due_between(calendar : Calendar, from : DateTime, until : DateTime) -> Array[Task]

fn tasks_due_on_date(calendar : Calendar, date : DateTime) -> Array[Task]

fn time_is_busy(calendar : Calendar, moment : DateTime) -> Bool

fn unescape_text(value : String) -> String

fn unfold_lines(input : String) -> Result[Array[(Int, String)], MoonCalError]

fn validate_calendar(calendar : Calendar) -> Array[Diagnostic]

fn validate_event(event : Event) -> Array[Diagnostic]

fn validate_freebusy(item : FreeBusy) -> Array[Diagnostic]

fn validate_task(task : Task) -> Array[Diagnostic]

fn weekday_to_string(day : Weekday) -> String