ClockTime Docs

AllDayOccurrence.Batch : { segments : U64, buffered : U64, status : [Complete(AllDayOccurrence(id)), Limited({ cursor : Cursor(id), reason : [WorkLimit, BufferLimit] })] }

AllDayOccurrence.Cursor

AllDayOccurrence.Cursor.collect : Cursor(id), SelectionLimits -> Try(Batch(id), [OutOfRange, ..])

AllDayOccurrence.Cursor.to_inspect : Cursor(id) -> Str

AllDayRecurrence.new : id, DateRecurrence, Window, U64, ZoneRules -> Try(AllDayRecurrence(id), [InvalidDuration, EmptyWindow, ReversedWindow, ..])

AllDayRecurrence.collect : AllDayRecurrence(id), { work : Limits, max_occurrences : U64 } -> Try(Batch(id), [OutOfRange, OutsideValidity, ..])

AllDayRecurrence.next : AllDayRecurrence(id), Limits -> Try(Next(id), [OutOfRange, OutsideValidity, ..])

AllDayRecurrence.outcomes : AllDayRecurrence(id), Limits -> Iter(Try(Next(id), [OutOfRange, OutsideValidity]))

AllDayRecurrence.to_inspect : AllDayRecurrence(id) -> Str

AllDayRecurrence.Limits : { max_date_steps : U64, max_date_buffered : U64, max_zone_segments : U64, max_zone_members : U64 }

AllDayRecurrence.Limit : [DateWorkLimit, DateBufferLimit, ZoneWorkLimit, ZoneBufferLimit, OutputLimit]

AllDayRecurrence.Batch : { occurrences : List(AllDayOccurrence({ series : id, date : GregorianDate })), date_steps : U64, zone_segments : U64, status : [Complete, Limited({ cursor : AllDayRecurrence(id), reason : Limit })] }

AllDayRecurrence.Next : { date_steps : U64, date_buffered : U64, zone_segments : U64, zone_buffered : U64, status : [End, Item({ occurrence : AllDayOccurrence({ series : id, date : GregorianDate }), cursor : AllDayRecurrence(id) }), Limited({ cursor : AllDayRecurrence(id), reason : Limit })] }

Calendar.is_eq : Calendar, Calendar -> Bool

Calendar.to_hash : Calendar, Hasher -> Hasher

Calendar.to_inspect : Calendar -> Str

Calendar.from_name : Str -> Try(Calendar, [UnsupportedCalendar(Str), ..])

Calendar.to_name : Calendar -> Str

CalendarArithmetic.shift_day : GregorianDate, CalendarDelta, Policy -> Try(GregorianDate, [OutOfRange, InvalidDestination(Fields), ..])

CalendarArithmetic.Policy : [Reject, Clamp, Carry]

CalendarDate.from_gregorian : GregorianDate -> CalendarDate

CalendarDate.from_julian : JulianDate -> CalendarDate

CalendarDate.from_fields : Calendar, Fields -> Try(CalendarDate, [OutOfRange, InvalidMonth, InvalidDay, ..])

CalendarDate.from_civil_day : Calendar, CivilDay -> Try(CalendarDate, [OutOfRange, ..])

CalendarDate.to_civil_day : CalendarDate -> CivilDay

CalendarDate.calendar : CalendarDate -> Calendar

CalendarDate.to_fields : CalendarDate -> Fields

CalendarDate.in_calendar : CalendarDate, Calendar -> Try(CalendarDate, [OutOfRange, ..])

CalendarDate.same_day : CalendarDate, CalendarDate -> Bool

CalendarDate.is_eq : CalendarDate, CalendarDate -> Bool

CalendarDate.to_hash : CalendarDate, Hasher -> Hasher

CalendarDate.to_inspect : CalendarDate -> Str

CalendarDate.Fields : { year : I64, month : U8, day : U8 }

CalendarDelta.from_components : Components -> CalendarDelta

CalendarDelta.to_components : CalendarDelta -> Components

CalendarDelta.years : I64 -> CalendarDelta

CalendarDelta.months : I64 -> CalendarDelta

CalendarDelta.days : I64 -> CalendarDelta

CalendarDelta.Components : { years : I64, months : I64, days : I64 }

CalendarEvidence.profile : Str

CalendarEvidence.new : QualifiedCalendarValue, List(CalendarValue) -> Try(CalendarEvidence, [InconsistentEvidence, TooManyAlternatives, CalendarMismatch(U64), ResolutionMismatch(U64), UnqualifiedComponent({ index : U64, scope : Scope }), CandidateOutOfRange(U64), ..])

CalendarEvidence.description : CalendarEvidence -> QualifiedCalendarValue

CalendarEvidence.alternatives : CalendarEvidence -> List(CalendarValue)

CalendarEvidence.query : CalendarEvidence, ZoneRules, PosixBoundary -> Try(Query, [OutsideValidity, OutOfRange, ..])

CalendarEvidence.is_eq : CalendarEvidence, CalendarEvidence -> Bool

CalendarEvidence.to_hash : CalendarEvidence, Hasher -> Hasher

CalendarEvidence.to_inspect : CalendarEvidence -> Str

CalendarEvidence.Truth : [Definite, Possible, Impossible]

CalendarEvidence.Batch : { examined : U64, status : [Complete(Truth), Limited(Query)] }

CalendarEvidence.Query

CalendarEvidence.Query.collect : Query, { max_alternatives : U64 } -> Batch

CalendarEvidence.Query.to_inspect : Query -> Str

CalendarPattern.definition : CalendarPattern -> Spec

CalendarPattern.defaults : Frequency -> Spec

CalendarPattern.new : GregorianDate, Spec -> Try(CalendarPattern, [InvalidInterval, TooManySelectors, InvalidSelector(Str), InvalidCombination(Str), ..])

CalendarPattern.period : CalendarPattern, U64 -> Try({ start : GregorianDate, end : GregorianDate }, [OutOfRange, ..])

CalendarPattern.matches : CalendarPattern, U64, GregorianDate -> Try(Bool, [OutOfRange, ..])

CalendarPattern.to_inspect : CalendarPattern -> Str

CalendarPattern.Frequency : [Daily, Weekly, Monthly, Yearly]

CalendarPattern.Weekday : [Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday]

CalendarPattern.Spec : { frequency : Frequency, interval : I64, week_start : Weekday, by_month : List(U8), by_month_day : List(I8), by_year_day : List(I16), by_week_no : List(I8), by_day : List({ ordinal : I8, weekday : Weekday }) }

CalendarPattern.Filter

CalendarPattern.Filter.new : Spec -> Try(Filter, [InvalidInterval, TooManySelectors, InvalidSelector(Str), InvalidCombination(Str), ..])

CalendarPattern.Filter.definition : Filter -> Spec

CalendarPattern.Filter.matches : Filter, GregorianDate -> Try(Bool, [OutOfRange, ..])

CalendarValue.year : Calendar, I64 -> Try(CalendarValue, [OutOfRange, InvalidMonth, InvalidDay, ..])

CalendarValue.month : Calendar, I64, U8 -> Try(CalendarValue, [OutOfRange, InvalidMonth, InvalidDay, ..])

CalendarValue.day : CalendarDate -> CalendarValue

CalendarValue.hour : CalendarDate, U8 -> Try(CalendarValue, [InvalidHour, InvalidMinute, InvalidSecond, UnsupportedLeapSecond, InvalidMicrosecond, ..])

CalendarValue.minute : CalendarDate, U8, U8 -> Try(CalendarValue, [InvalidHour, InvalidMinute, InvalidSecond, UnsupportedLeapSecond, InvalidMicrosecond, ..])

CalendarValue.second : CalendarDate, U8, U8, U8 -> Try(CalendarValue, [InvalidHour, InvalidMinute, InvalidSecond, UnsupportedLeapSecond, InvalidMicrosecond, ..])

CalendarValue.fractional_second : CalendarDate, { hour : U8, minute : U8, second : U8 }, { value : U32, digits : U8 } -> Try(CalendarValue, [InvalidFraction, UnsupportedPrecision, InvalidHour, InvalidMinute, InvalidSecond, UnsupportedLeapSecond, InvalidMicrosecond, ..])

CalendarValue.resolution : CalendarValue -> Resolution

CalendarValue.start_label : CalendarValue -> LocalDateTime

CalendarValue.local_bounds : CalendarValue -> Try({ start : LocalDateTime, end : LocalDateTime }, [OutOfRange, ..])

CalendarValue.selection_cursor : CalendarValue, ZoneRules -> Try(SelectionCursor, [OutOfRange, EmptySelection, ReversedSelection, OutsideValidity, ..])

CalendarValue.is_eq : CalendarValue, CalendarValue -> Bool

CalendarValue.to_hash : CalendarValue, Hasher -> Hasher

CalendarValue.fact_count : CalendarValue -> U64

CalendarValue.fact_at : CalendarValue, U64 -> [End, Item(SemanticFact)]

CalendarValue.to_inspect : CalendarValue -> Str

CalendarValue.Resolution : [Year, Month, Day, Hour, Minute, Second, Fraction(U8)]

CivilDay.from_day_number : I64 -> CivilDay

CivilDay.to_day_number : CivilDay -> I64

CivilDay.is_lt : CivilDay, CivilDay -> Bool

CivilDay.is_lte : CivilDay, CivilDay -> Bool

CivilDay.is_gt : CivilDay, CivilDay -> Bool

CivilDay.is_gte : CivilDay, CivilDay -> Bool

CivilDay.to_hash : CivilDay, Hasher -> Hasher

CivilDay.to_inspect : CivilDay -> Str

CivilDay.is_eq : CivilDay, CivilDay -> Bool

CivilDay.compare : CivilDay, CivilDay -> [LT, EQ, GT]

ClockPattern.new : ClockTime, Spec -> Try(ClockPattern, [TooManySelectors, InvalidHour, InvalidMinute, InvalidSecond, UnsupportedLeapSecond, ..])

ClockPattern.definition : ClockPattern -> { hours : List(U8), minutes : List(U8), seconds : List(U8), microsecond : U32 }

ClockPattern.count : ClockPattern -> U64

ClockPattern.at : ClockPattern, U64 -> Try(ClockTime, [OutOfRange, ..])

ClockPattern.iter : ClockPattern -> Iter(ClockTime)

ClockPattern.to_inspect : ClockPattern -> Str

ClockPattern.Spec : { hours : List(U8), minutes : List(U8), seconds : List(U8) }

ClockTime.from_fields : Fields -> Try(ClockTime, [InvalidHour, InvalidMinute, InvalidSecond, UnsupportedLeapSecond, InvalidMicrosecond, ..])

ClockTime.from_microseconds_since_midnight : I64 -> Try(ClockTime, [OutOfRange, ..])

ClockTime.to_microseconds_since_midnight : ClockTime -> I64

ClockTime.to_fields : ClockTime -> Fields

ClockTime.is_eq : ClockTime, ClockTime -> Bool

ClockTime.is_lt : ClockTime, ClockTime -> Bool

ClockTime.is_lte : ClockTime, ClockTime -> Bool

ClockTime.is_gt : ClockTime, ClockTime -> Bool

ClockTime.is_gte : ClockTime, ClockTime -> Bool

ClockTime.to_hash : ClockTime, Hasher -> Hasher

ClockTime.to_inspect : ClockTime -> Str

ClockTime.Fields : { hour : U8, minute : U8, second : U8, microsecond : U32 }

Coverage.empty : Coverage

Coverage.from_spans : List(PosixSpan) -> Coverage

Coverage.from_sorted_spans : List(PosixSpan) -> Try(Coverage, [UnsortedInput, ..])

Coverage.to_spans : Coverage -> List(PosixSpan)

Coverage.member_count : Coverage -> U64

Coverage.iter : Coverage -> Iter(PosixSpan)

Coverage.to_hash : Coverage, Hasher -> Hasher

Coverage.fact_count : Coverage -> U64

Coverage.fact_at : Coverage, U64 -> [End, Item(SemanticFact)]

Coverage.to_inspect : Coverage -> Str

Coverage.is_eq : Coverage, Coverage -> Bool

Coverage.coordinate_width : Coverage -> Try(PosixDelta, [OutOfRange, ..])

Coverage.contains : Coverage, PosixBoundary -> Bool

Coverage.fold_overlaps : Coverage, PosixSpan, state, (state, PosixSpan -> state) -> state

Coverage.overlapping_spans : Coverage, PosixSpan -> List(PosixSpan)

Coverage.union : Coverage, Coverage -> Coverage

Coverage.intersection : Coverage, Coverage -> Coverage

Coverage.difference : Coverage, Coverage -> Coverage

Coverage.complement_within : Coverage, PosixSpan -> Coverage

Coverage.SortedBuilder

Coverage.SortedBuilder.empty : SortedBuilder

Coverage.SortedBuilder.member_count : SortedBuilder -> U64

Coverage.SortedBuilder.append : SortedBuilder, PosixSpan -> Try(SortedBuilder, [UnsortedInput, ..])

Coverage.SortedBuilder.append_bounded : SortedBuilder, PosixSpan, U64 -> Try([Added(SortedBuilder), Full], [UnsortedInput, ..])

Coverage.SortedBuilder.append_retaining : SortedBuilder, PosixSpan, U64 -> Try([Added(SortedBuilder), Full(SortedBuilder)], [UnsortedInput, ..])

Coverage.SortedBuilder.to_coverage : SortedBuilder -> Coverage

Coverage.SortedBuilder.to_inspect : SortedBuilder -> Str

DateRecurrence.new : GregorianDate, Spec -> Try(DateRecurrence, [InvalidInterval, TooManySelectors, InvalidSelector(Str), InvalidCombination(Str), InvalidCount, InvalidUntil, UnsynchronizedStart, OutOfRange, ..])

DateRecurrence.cursor : DateRecurrence, Window -> Try(Cursor, [EmptyWindow, ReversedWindow, ..])

DateRecurrence.fact_count : DateRecurrence -> U64

DateRecurrence.fact_at : DateRecurrence, U64 -> [End, Item(SemanticFact)]

DateRecurrence.to_inspect : DateRecurrence -> Str

DateRecurrence.Termination : [Forever, Count(U64), Until(GregorianDate)]

DateRecurrence.Spec : { pattern : Spec, termination : Termination, by_set_pos : List(I16), inclusions : List(GregorianDate), exclusions : List(GregorianDate) }

DateRecurrence.Window : { start : GregorianDate, end : GregorianDate }

DateRecurrence.Limits : { max_steps : U64, max_buffered : U64, max_occurrences : U64 }

DateRecurrence.Limit : [WorkLimit, BufferLimit, OutputLimit]

DateRecurrence.Batch : { dates : List(GregorianDate), steps : U64, buffered : U64, status : [Complete, Limited({ cursor : Cursor, reason : Limit })] }

DateRecurrence.FoldBatch : { value : acc, occurrences : U64, steps : U64, buffered : U64, status : [Complete, Limited({ cursor : Cursor, reason : Limit }), Stopped(Cursor)] }

DateRecurrence.Next : { steps : U64, buffered : U64, status : [End, Item({ date : GregorianDate, cursor : Cursor }), Limited({ cursor : Cursor, reason : Limit })] }

DateRecurrence.Cursor

DateRecurrence.Cursor.collect : Cursor, Limits -> Try(Batch, [OutOfRange, ..])

DateRecurrence.Cursor.fold : Cursor, Limits, acc, (acc, GregorianDate -> [Continue(acc), Stop(acc)]) -> Try(FoldBatch(acc), [OutOfRange, ..])

DateRecurrence.Cursor.next : Cursor, { max_steps : U64, max_buffered : U64 } -> Try(Next, [OutOfRange, ..])

DateRecurrence.Cursor.chunks : Cursor, Limits -> Iter(Try(Batch, [OutOfRange]))

DateRecurrence.Cursor.to_inspect : Cursor -> Str

EdtfDate.parser_for : encoding -> (state -> Try({ value : EdtfDate, rest : state }, [InvalidEdtfDate(Error), Encoding(err), ..])) where [encoding.parse_str : encoding, state -> Try({ value : Str, rest : state }, err)]

EdtfDate.encoder_for : encoding -> (EdtfDate, state -> Try(state, err)) where [encoding.encode_str : Str, state -> Try(state, err)]

EdtfDate.from_quote : Str -> Try(EdtfDate, [BadQuotedBytes(Str)])

EdtfDate.profile : Str

EdtfDate.parse : Str -> Try(EdtfDate, Error)

EdtfDate.from_description : QualifiedCalendarValue -> Try(EdtfDate, Error)

EdtfDate.description : EdtfDate -> QualifiedCalendarValue

EdtfDate.to_text : EdtfDate -> Str

EdtfDate.is_eq : EdtfDate, EdtfDate -> Bool

EdtfDate.to_hash : EdtfDate, Hasher -> Hasher

EdtfDate.fact_count : EdtfDate -> U64

EdtfDate.fact_at : EdtfDate, U64 -> [End, Item(SemanticFact)]

EdtfDate.to_inspect : EdtfDate -> Str

EdtfDate.Error : [Malformed, Incomplete, TooLarge, OutOfRange, UnsupportedForm, UnsupportedCalendar, UnsupportedResolution, UnsupportedQualification]

EventCollection.from_entries : List({ id : id, span : PosixSpan }) -> Try(EventCollection(id), [DuplicateId(id), ..]) where [id.is_eq : id, id -> Bool, id.to_hash : id, Hasher -> Hasher]

EventCollection.event_count : EventCollection(id) -> U64

EventCollection.to_entries : EventCollection(id) -> List({ id : id, span : PosixSpan })

EventCollection.iter : EventCollection(id) -> Iter({ id : id, span : PosixSpan })

EventCollection.to_coverage : EventCollection(id) -> Coverage

EventCollection.clip : EventCollection(id), Coverage -> List({ id : id, coverage : Coverage })

EventCollection.segments : EventCollection(id) -> List({ span : PosixSpan, contributors : List(id) })

EventCollection.to_inspect : EventCollection(id) -> Str

ExactInterval.parser_for : encoding -> (state -> Try({ value : ExactInterval, rest : state }, [InvalidExactInterval(Error), Encoding(err), ..])) where [encoding.parse_str : encoding, state -> Try({ value : Str, rest : state }, err)]

ExactInterval.encoder_for : encoding -> (ExactInterval, state -> Try(state, err)) where [encoding.encode_str : Str, state -> Try(state, err)]

ExactInterval.from_quote : Str -> Try(ExactInterval, [BadQuotedBytes(Str)])

ExactInterval.profile : Str

ExactInterval.new : OffsetTimestamp, OffsetTimestamp -> Try(ExactInterval, Error)

ExactInterval.parse : Str -> Try(ExactInterval, Error)

ExactInterval.endpoints : ExactInterval -> { start : OffsetTimestamp, end : OffsetTimestamp }

ExactInterval.span : ExactInterval -> PosixSpan

ExactInterval.to_text : ExactInterval -> Str

ExactInterval.from_span : PosixSpan, Offset, U8 -> Try(ExactInterval, Error)

ExactInterval.is_eq : ExactInterval, ExactInterval -> Bool

ExactInterval.to_hash : ExactInterval, Hasher -> Hasher

ExactInterval.fact_count : ExactInterval -> U64

ExactInterval.fact_at : ExactInterval, U64 -> [End, Item(SemanticFact)]

ExactInterval.to_inspect : ExactInterval -> Str

ExactInterval.Error : [Malformed, Incomplete, TooLarge, Start(Error), End(Error), EmptySpan, ReversedBounds]

Explanation.new : Source -> Explanation

Explanation.fact_count : Explanation -> U64

Explanation.fact_at : Explanation, U64 -> [End, Item(SemanticFact)]

Explanation.plain : Explanation, Budget -> Report

Explanation.to_inspect : Explanation -> Str

Explanation.Source : [DateRecurrence(DateRecurrence), TimedRecurrence(TimedRecurrence), RfcTimedRule(RfcTimedRule), Coverage(Coverage), ResolvedBoundary(ResolvedBoundary), ResolvedSelection(ResolvedSelection), SelectionBatch(Batch), CalendarValue(CalendarValue), QualifiedCalendarValue(QualifiedCalendarValue), EdtfDate(EdtfDate), OffsetTimestamp(OffsetTimestamp), Ixdtf(Ixdtf), Snapshot(Snapshot), ExactInterval(ExactInterval), RfcDateTime(RfcDateTime), RfcDuration(RfcDuration), RfcPeriod(RfcPeriod)]

Explanation.Budget : { max_facts : U64, max_utf8_bytes : U64 }

Explanation.Report : { text : Str, status : [Complete, Limited([FactLimit, ByteLimit, TextLimit])], visited_facts : U64, total_facts : U64 }

FixedOffset.from_seconds : I32 -> FixedOffset

FixedOffset.to_seconds : FixedOffset -> I32

FixedOffset.resolve : FixedOffset, LocalDateTime -> Try(PosixBoundary, [OutOfRange, ..])

FixedOffset.project : FixedOffset, PosixBoundary, Calendar -> Try(LocalDateTime, [OutOfRange, ..])

FixedOffset.is_eq : FixedOffset, FixedOffset -> Bool

FixedOffset.to_hash : FixedOffset, Hasher -> Hasher

FixedOffset.to_inspect : FixedOffset -> Str

GregorianDate.from_fields : Fields -> Try(GregorianDate, [OutOfRange, InvalidMonth, InvalidDay, ..])

GregorianDate.days_in_month : I64, U8 -> Try(U8, [OutOfRange, InvalidMonth, ..])

GregorianDate.to_fields : GregorianDate -> Fields

GregorianDate.to_civil_day : GregorianDate -> CivilDay

GregorianDate.from_civil_day : CivilDay -> Try(GregorianDate, [OutOfRange, ..])

GregorianDate.to_hash : GregorianDate, Hasher -> Hasher

GregorianDate.to_inspect : GregorianDate -> Str

GregorianDate.is_lt : GregorianDate, GregorianDate -> Bool

GregorianDate.is_lte : GregorianDate, GregorianDate -> Bool

GregorianDate.is_gt : GregorianDate, GregorianDate -> Bool

GregorianDate.is_gte : GregorianDate, GregorianDate -> Bool

GregorianDate.is_eq : GregorianDate, GregorianDate -> Bool

GregorianDate.Fields : { year : I64, month : U8, day : U8 }

IntervalEvidence.profile : Str

IntervalEvidence.paired : List(PosixSpan) -> Try(IntervalEvidence, [InconsistentEvidence, TooManyAlternatives, ..])

IntervalEvidence.independent : { starts : List(PosixBoundary), ends : List(PosixBoundary) } -> Try(IntervalEvidence, [InconsistentEvidence, TooManyAlternatives, ..])

IntervalEvidence.contains : IntervalEvidence, PosixBoundary -> Truth

IntervalEvidence.possible_coverage : IntervalEvidence -> Coverage

IntervalEvidence.definite_coverage : IntervalEvidence -> Coverage

IntervalEvidence.declaration : IntervalEvidence -> Declaration

IntervalEvidence.is_eq : IntervalEvidence, IntervalEvidence -> Bool

IntervalEvidence.to_hash : IntervalEvidence, Hasher -> Hasher

IntervalEvidence.to_inspect : IntervalEvidence -> Str

IntervalEvidence.Declaration : [Paired(List(PosixSpan)), Independent({ starts : List(PosixBoundary), ends : List(PosixBoundary) })]

IntervalEvidence.Truth : [Definite, Possible, Impossible]

Ixdtf.parser_for : encoding -> (state -> Try({ value : Ixdtf, rest : state }, [InvalidIxdtf(Error), Encoding(err), ..])) where [encoding.parse_str : encoding, state -> Try({ value : Str, rest : state }, err)]

Ixdtf.encoder_for : encoding -> (Ixdtf, state -> Try(state, err)) where [encoding.encode_str : Str, state -> Try(state, err)]

Ixdtf.from_quote : Str -> Try(Ixdtf, [BadQuotedBytes(Str)])

Ixdtf.profile : Str

Ixdtf.new : Parts -> Try(Ixdtf, Error)

Ixdtf.parts : Ixdtf -> Parts

Ixdtf.parse : Str -> Try(Ixdtf, Error)

Ixdtf.preferred_calendar : Ixdtf -> [None, Some(Str)]

Ixdtf.to_text : Ixdtf -> Str

Ixdtf.is_eq : Ixdtf, Ixdtf -> Bool

Ixdtf.to_hash : Ixdtf, Hasher -> Hasher

Ixdtf.fact_count : Ixdtf -> U64

Ixdtf.fact_at : Ixdtf, U64 -> [End, Item(SemanticFact)]

Ixdtf.to_inspect : Ixdtf -> Str

Ixdtf.resolve : Ixdtf, [None, Some(ZoneRules)] -> Try(Snapshot, ResolveError)

Ixdtf.ZoneId : [Named(Str), Numeric(FixedOffset)]

Ixdtf.Zone : { critical : Bool, identifier : ZoneId }

Ixdtf.Tag : { critical : Bool, key : Str, value : Str }

Ixdtf.Parts : { timestamp : OffsetTimestamp, zone : [None, Some(Zone)], tags : List(Tag) }

Ixdtf.Error : [Base(Error), Malformed, Incomplete, TooLarge, TooManyAnnotations, InvalidZone, InvalidTag, ExperimentalKey, UnknownCritical, ConflictingCritical, UnsupportedCriticalCalendar]

Ixdtf.ResolveError : [NeedsContext, UnexpectedContext, ZoneMismatch, OffsetConflict, OutsideValidity, OutOfRange]

Ixdtf.Snapshot

Ixdtf.Snapshot.resolve : Ixdtf, [None, Some(ZoneRules)] -> Try(Snapshot, ResolveError)

Ixdtf.Snapshot.source : Snapshot -> Ixdtf

Ixdtf.Snapshot.context : Snapshot -> [None, Some(ZoneRules)]

Ixdtf.Snapshot.boundary : Snapshot -> PosixBoundary

Ixdtf.Snapshot.offset : Snapshot -> FixedOffset

Ixdtf.Snapshot.presentation : Snapshot -> Try(LocalDateTime, [UnsupportedCalendar(Str)])

Ixdtf.Snapshot.reresolve : Snapshot, [None, Some(ZoneRules)] -> Try(Snapshot, ResolveError)

Ixdtf.Snapshot.same_position : Snapshot, Snapshot -> Bool

Ixdtf.Snapshot.is_eq : Snapshot, Snapshot -> Bool

Ixdtf.Snapshot.to_hash : Snapshot, Hasher -> Hasher

Ixdtf.Snapshot.fact_count : Snapshot -> U64

Ixdtf.Snapshot.fact_at : Snapshot, U64 -> [End, Item(SemanticFact)]

Ixdtf.Snapshot.to_inspect : Snapshot -> Str

JulianDate.from_fields : Fields -> Try(JulianDate, [OutOfRange, InvalidMonth, InvalidDay, ..])

JulianDate.days_in_month : I64, U8 -> Try(U8, [OutOfRange, InvalidMonth, ..])

JulianDate.to_fields : JulianDate -> Fields

JulianDate.to_civil_day : JulianDate -> CivilDay

JulianDate.from_civil_day : CivilDay -> Try(JulianDate, [OutOfRange, ..])

JulianDate.to_hash : JulianDate, Hasher -> Hasher

JulianDate.to_inspect : JulianDate -> Str

JulianDate.is_lt : JulianDate, JulianDate -> Bool

JulianDate.is_lte : JulianDate, JulianDate -> Bool

JulianDate.is_gt : JulianDate, JulianDate -> Bool

JulianDate.is_gte : JulianDate, JulianDate -> Bool

JulianDate.is_eq : JulianDate, JulianDate -> Bool

JulianDate.Fields : { year : I64, month : U8, day : U8 }

LocalDateTime.new : CalendarDate, ClockTime -> LocalDateTime

LocalDateTime.date : LocalDateTime -> CalendarDate

LocalDateTime.clock : LocalDateTime -> ClockTime

LocalDateTime.in_calendar : LocalDateTime, Calendar -> Try(LocalDateTime, [OutOfRange, ..])

LocalDateTime.compare_position : LocalDateTime, LocalDateTime -> [LT, EQ, GT]

LocalDateTime.same_position : LocalDateTime, LocalDateTime -> Bool

LocalDateTime.is_eq : LocalDateTime, LocalDateTime -> Bool

LocalDateTime.to_hash : LocalDateTime, Hasher -> Hasher

LocalDateTime.to_inspect : LocalDateTime -> Str

OffsetTimestamp.parser_for : encoding -> (state -> Try({ value : OffsetTimestamp, rest : state }, [InvalidOffsetTimestamp(Error), Encoding(err), ..])) where [encoding.parse_str : encoding, state -> Try({ value : Str, rest : state }, err)]

OffsetTimestamp.encoder_for : encoding -> (OffsetTimestamp, state -> Try(state, err)) where [encoding.encode_str : Str, state -> Try(state, err)]

OffsetTimestamp.from_quote : Str -> Try(OffsetTimestamp, [BadQuotedBytes(Str)])

OffsetTimestamp.profile : Str

OffsetTimestamp.new : Parts -> Try(OffsetTimestamp, Error)

OffsetTimestamp.parts : OffsetTimestamp -> Parts

OffsetTimestamp.local_label : OffsetTimestamp -> LocalDateTime

OffsetTimestamp.boundary : OffsetTimestamp -> Try(PosixBoundary, [OutOfRange, ..])

OffsetTimestamp.from_boundary : PosixBoundary, Offset, U8 -> Try(OffsetTimestamp, Error)

OffsetTimestamp.parse : Str -> Try(OffsetTimestamp, Error)

OffsetTimestamp.to_text : OffsetTimestamp -> Str

OffsetTimestamp.is_eq : OffsetTimestamp, OffsetTimestamp -> Bool

OffsetTimestamp.to_hash : OffsetTimestamp, Hasher -> Hasher

OffsetTimestamp.fact_count : OffsetTimestamp -> U64

OffsetTimestamp.fact_at : OffsetTimestamp, U64 -> [End, Item(SemanticFact)]

OffsetTimestamp.to_inspect : OffsetTimestamp -> Str

OffsetTimestamp.Offset : [UnassertedUtc, Asserted(FixedOffset)]

OffsetTimestamp.Parts : { date : GregorianDate, clock : ClockTime, fraction_digits : U8, offset : Offset }

OffsetTimestamp.Error : [Malformed, Incomplete, InvalidDate, InvalidTime, InvalidOffset, OutOfRange, TooLarge, UnsupportedPrecision, UnsupportedLeapSecond, UnsupportedAnnotations]

Persistence.new : Value -> Try(Persistence, [InvalidCivilSnapshot(Error), InvalidSnapshot(Error), TooManyMembers, ..])

Persistence.value : Persistence -> Value

Persistence.parse : Str -> Try(Persistence, Error)

Persistence.to_text : Persistence -> Str

Persistence.is_eq : Persistence, Persistence -> Bool

Persistence.to_hash : Persistence, Hasher -> Hasher

Persistence.to_inspect : Persistence -> Str

Persistence.Value : [ResolvedBoundary(ResolvedBoundary), ResolvedSelection(ResolvedSelection), IxdtfSnapshot(Snapshot), EdtfDate(EdtfDate), OffsetTimestamp(OffsetTimestamp), ExactInterval(ExactInterval), Ixdtf(Ixdtf), RfcDateTime(RfcDateTime), RfcDuration(RfcDuration), RfcPeriod(RfcPeriod), PosixBoundary(PosixBoundary), PosixDelta(PosixDelta), PosixSpan(PosixSpan), Coverage(Coverage), CalendarValue(CalendarValue), QualifiedCalendarValue(QualifiedCalendarValue)]

Persistence.Error : [InvalidCivilSnapshot(Error), InvalidSnapshot(Error), InvalidCalendarValue(Error), InvalidQualifiedCalendarValue(Error), Envelope(Error), UnknownFormat(Str), UnknownVersion(Str), UnknownKind(Str), UnsupportedProfile(Str), UnsupportedAxis(Str), UnsupportedUnit(Str), InvalidEdtfDate(Error), InvalidOffsetTimestamp(Error), InvalidExactInterval(Error), InvalidIxdtf(Error), InvalidRfcDateTime(Error), InvalidRfcDuration(Error), InvalidRfcPeriod(Error), InvalidInteger, OutOfRange, MalformedSpan, IncompleteSpan, InvalidSpan([EmptySpan, ReversedBounds]), NonCanonicalCoverage, TooManyMembers]

PosixBoundary.from_microseconds : I64 -> PosixBoundary

PosixBoundary.to_microseconds : PosixBoundary -> I64

PosixBoundary.from_nanoseconds : I128 -> Try(PosixBoundary, [Submicrosecond, OutOfRange, ..])

PosixBoundary.from_nanoseconds_with_rounding : I128, Rounding -> Try(PosixBoundary, [Submicrosecond, OutOfRange, ..])

PosixBoundary.from_seconds : Dec, Rounding -> Try(PosixBoundary, [Submicrosecond, OutOfRange, ..])

PosixBoundary.compare : PosixBoundary, PosixBoundary -> [LT, EQ, GT]

PosixBoundary.is_lt : PosixBoundary, PosixBoundary -> Bool

PosixBoundary.is_lte : PosixBoundary, PosixBoundary -> Bool

PosixBoundary.is_gt : PosixBoundary, PosixBoundary -> Bool

PosixBoundary.is_gte : PosixBoundary, PosixBoundary -> Bool

PosixBoundary.to_hash : PosixBoundary, Hasher -> Hasher

PosixBoundary.to_inspect : PosixBoundary -> Str

PosixBoundary.is_eq : PosixBoundary, PosixBoundary -> Bool

PosixBoundary.shift : PosixBoundary, PosixDelta -> Try(PosixBoundary, [OutOfRange, ..])

PosixBoundary.difference : PosixBoundary, PosixBoundary -> Try(PosixDelta, [OutOfRange, ..])

PosixBoundary.Rounding : [RejectSubmicrosecond, Floor, Ceiling, TowardZero, NearestTiesEven]

PosixDelta.from_microseconds : I64 -> PosixDelta

PosixDelta.to_microseconds : PosixDelta -> I64

PosixDelta.is_lt : PosixDelta, PosixDelta -> Bool

PosixDelta.is_lte : PosixDelta, PosixDelta -> Bool

PosixDelta.is_gt : PosixDelta, PosixDelta -> Bool

PosixDelta.is_gte : PosixDelta, PosixDelta -> Bool

PosixDelta.to_hash : PosixDelta, Hasher -> Hasher

PosixDelta.to_inspect : PosixDelta -> Str

PosixDelta.is_eq : PosixDelta, PosixDelta -> Bool

PosixSpan.new : PosixBoundary, PosixBoundary -> Try(PosixSpan, [EmptySpan, ReversedBounds, ..])

PosixSpan.from_seconds : Dec, Dec, Rounding -> Try(PosixSpan, [EmptySpan, ReversedBounds, Submicrosecond, OutOfRange, ..])

PosixSpan.start : PosixSpan -> PosixBoundary

PosixSpan.end : PosixSpan -> PosixBoundary

PosixSpan.coordinate_width : PosixSpan -> Try(PosixDelta, [OutOfRange, ..])

PosixSpan.microsecond_at : PosixBoundary -> Try(PosixSpan, [OutOfRange, ..])

PosixSpan.to_hash : PosixSpan, Hasher -> Hasher

PosixSpan.to_inspect : PosixSpan -> Str

PosixSpan.is_eq : PosixSpan, PosixSpan -> Bool

PosixSpan.hull : PosixSpan, PosixSpan -> PosixSpan

PosixSpan.intersection : PosixSpan, PosixSpan -> [Empty, Span(PosixSpan)]

PosixSpan.overlaps : PosixSpan, PosixSpan -> Bool

PosixSpan.contains : PosixSpan, PosixBoundary -> Bool

PosixSpan.relation : PosixSpan, PosixSpan -> [Before, Meets, Overlaps, Starts, During, Finishes, Equal, FinishedBy, Contains, StartedBy, OverlappedBy, MetBy, After]

QualifiedCalendarValue.new : CalendarValue, List(Qualification) -> Try(QualifiedCalendarValue, [TooManyQualifications, DuplicateScope(Scope), UnsuppliedComponent(Scope), ..])

QualifiedCalendarValue.described_value : QualifiedCalendarValue -> CalendarValue

QualifiedCalendarValue.qualifications : QualifiedCalendarValue -> List(Qualification)

QualifiedCalendarValue.selection_cursor : QualifiedCalendarValue, ZoneRules -> Try(SelectionCursor, [NeedsModel, OutOfRange, EmptySelection, ReversedSelection, OutsideValidity, ..])

QualifiedCalendarValue.is_eq : QualifiedCalendarValue, QualifiedCalendarValue -> Bool

QualifiedCalendarValue.to_hash : QualifiedCalendarValue, Hasher -> Hasher

QualifiedCalendarValue.fact_count : QualifiedCalendarValue -> U64

QualifiedCalendarValue.fact_at : QualifiedCalendarValue, U64 -> [End, Item(SemanticFact)]

QualifiedCalendarValue.to_inspect : QualifiedCalendarValue -> Str

QualifiedCalendarValue.Scope : [Whole, Year, Month, Day, Hour, Minute, Second, Fraction]

QualifiedCalendarValue.Qualifier : [Uncertain, Approximate, UncertainApproximate]

QualifiedCalendarValue.Qualification : { scope : Scope, qualifier : Qualifier }

ResolvedBoundary.resolve : ZoneRules, LocalDateTime, OccurrencePolicy -> Try(ResolvedBoundary, [Gap, Ambiguous, OffsetConflict, OutsideValidity, OutOfRange, ..])

ResolvedBoundary.boundary : ResolvedBoundary -> PosixBoundary

ResolvedBoundary.source : ResolvedBoundary -> LocalDateTime

ResolvedBoundary.policy : ResolvedBoundary -> OccurrencePolicy

ResolvedBoundary.rules : ResolvedBoundary -> ZoneRules

ResolvedBoundary.offset : ResolvedBoundary -> FixedOffset

ResolvedBoundary.reresolve : ResolvedBoundary, ZoneRules -> Try(ResolvedBoundary, [Gap, Ambiguous, OffsetConflict, OutsideValidity, OutOfRange, ..])

ResolvedBoundary.same_position : ResolvedBoundary, ResolvedBoundary -> Bool

ResolvedBoundary.is_eq : ResolvedBoundary, ResolvedBoundary -> Bool

ResolvedBoundary.to_hash : ResolvedBoundary, Hasher -> Hasher

ResolvedBoundary.fact_count : ResolvedBoundary -> U64

ResolvedBoundary.fact_at : ResolvedBoundary, U64 -> [End, Item(SemanticFact)]

ResolvedBoundary.to_inspect : ResolvedBoundary -> Str

ResolvedSelection.resolve : ZoneRules, LocalDateTime, LocalDateTime -> Try(ResolvedSelection, [EmptySelection, ReversedSelection, OutsideValidity, OutOfRange, ..])

ResolvedSelection.collect : SelectionCursor, SelectionLimits -> Try(Batch, [OutOfRange, ..])

ResolvedSelection.coverage : ResolvedSelection -> Coverage

ResolvedSelection.start : ResolvedSelection -> LocalDateTime

ResolvedSelection.end : ResolvedSelection -> LocalDateTime

ResolvedSelection.rules : ResolvedSelection -> ZoneRules

ResolvedSelection.reresolve : ResolvedSelection, ZoneRules -> Try(ResolvedSelection, [EmptySelection, ReversedSelection, OutsideValidity, OutOfRange, ..])

ResolvedSelection.same_extent : ResolvedSelection, ResolvedSelection -> Bool

ResolvedSelection.is_eq : ResolvedSelection, ResolvedSelection -> Bool

ResolvedSelection.to_hash : ResolvedSelection, Hasher -> Hasher

ResolvedSelection.fact_count : ResolvedSelection -> U64

ResolvedSelection.fact_at : ResolvedSelection, U64 -> [End, Item(SemanticFact)]

ResolvedSelection.batch_fact_count : Batch -> U64

ResolvedSelection.batch_fact_at : Batch, U64 -> [End, Item(SemanticFact)]

ResolvedSelection.to_inspect : ResolvedSelection -> Str

ResolvedSelection.Batch : { segments : U64, buffered : U64, status : [Complete(ResolvedSelection), Limited({ cursor : SelectionCursor, reason : [WorkLimit, BufferLimit] })] }

RfcDateRule.profile : Str

RfcDateRule.parse : Parts -> Try(DateRecurrence, Error)

RfcDateRule.Parts : { start : Str, rule : Str, inclusions : List(Str), exclusions : List(Str) }

RfcDateRule.Error : [Malformed(Str), Duplicate(Str), Missing(Str), Unsupported(Str), OutOfRange(Str), Incompatible(Str), InvalidDate(Str), TooLarge, InvalidRule([InvalidInterval, TooManySelectors, InvalidSelector(Str), InvalidCombination(Str), InvalidCount, InvalidUntil, UnsynchronizedStart, OutOfRange])]

RfcDateTime.parser_for : encoding -> (state -> Try({ value : RfcDateTime, rest : state }, [InvalidRfcDateTime(Error), Encoding(err), ..])) where [encoding.parse_str : encoding, state -> Try({ value : Str, rest : state }, err)]

RfcDateTime.encoder_for : encoding -> (RfcDateTime, state -> Try(state, err)) where [encoding.encode_str : Str, state -> Try(state, err)]

RfcDateTime.from_quote : Str -> Try(RfcDateTime, [BadQuotedBytes(Str)])

RfcDateTime.profile : Str

RfcDateTime.parse : Str -> Try(RfcDateTime, Error)

RfcDateTime.form : RfcDateTime -> Form

RfcDateTime.source : RfcDateTime -> { date : GregorianDate, clock : ClockTime }

RfcDateTime.local_label : RfcDateTime -> LocalDateTime

RfcDateTime.utc_boundary : RfcDateTime -> Try(PosixBoundary, [NeedsContext, OutOfRange, ..])

RfcDateTime.to_text : RfcDateTime -> Str

RfcDateTime.is_eq : RfcDateTime, RfcDateTime -> Bool

RfcDateTime.to_hash : RfcDateTime, Hasher -> Hasher

RfcDateTime.fact_count : RfcDateTime -> U64

RfcDateTime.fact_at : RfcDateTime, U64 -> [End, Item(SemanticFact)]

RfcDateTime.to_inspect : RfcDateTime -> Str

RfcDateTime.Form : [Local, Utc]

RfcDateTime.Error : [Malformed, Incomplete, OutOfRange, InvalidDate, InvalidTime, UnsupportedLeapSecond]

RfcDuration.parser_for : encoding -> (state -> Try({ value : RfcDuration, rest : state }, [InvalidRfcDuration(Error), Encoding(err), ..])) where [encoding.parse_str : encoding, state -> Try({ value : Str, rest : state }, err)]

RfcDuration.encoder_for : encoding -> (RfcDuration, state -> Try(state, err)) where [encoding.encode_str : Str, state -> Try(state, err)]

RfcDuration.from_quote : Str -> Try(RfcDuration, [BadQuotedBytes(Str)])

RfcDuration.profile : Str

RfcDuration.parse : Str -> Try(RfcDuration, Error)

RfcDuration.is_eq : RfcDuration, RfcDuration -> Bool

RfcDuration.to_hash : RfcDuration, Hasher -> Hasher

RfcDuration.components : RfcDuration -> { days : I64, seconds : I64 }

RfcDuration.to_duration : RfcDuration -> Duration

RfcDuration.to_text : RfcDuration -> Str

RfcDuration.fact_count : RfcDuration -> U64

RfcDuration.fact_at : RfcDuration, U64 -> [End, Item(SemanticFact)]

RfcDuration.to_inspect : RfcDuration -> Str

RfcDuration.Error : [Malformed, NonPositive, OutOfRange, TooLarge]

RfcPeriod.parser_for : encoding -> (state -> Try({ value : RfcPeriod, rest : state }, [InvalidRfcPeriod(Error), Encoding(err), ..])) where [encoding.parse_str : encoding, state -> Try({ value : Str, rest : state }, err)]

RfcPeriod.encoder_for : encoding -> (RfcPeriod, state -> Try(state, err)) where [encoding.encode_str : Str, state -> Try(state, err)]

RfcPeriod.from_quote : Str -> Try(RfcPeriod, [BadQuotedBytes(Str)])

RfcPeriod.profile : Str

RfcPeriod.parse : Str -> Try(RfcPeriod, Error)

RfcPeriod.start : RfcPeriod -> RfcDateTime

RfcPeriod.ending : RfcPeriod -> Ending

RfcPeriod.to_text : RfcPeriod -> Str

RfcPeriod.is_eq : RfcPeriod, RfcPeriod -> Bool

RfcPeriod.to_hash : RfcPeriod, Hasher -> Hasher

RfcPeriod.fact_count : RfcPeriod -> U64

RfcPeriod.fact_at : RfcPeriod, U64 -> [End, Item(SemanticFact)]

RfcPeriod.to_inspect : RfcPeriod -> Str

RfcPeriod.schedule : id, TimedRecurrence, Window, RfcDuration, List(RfcPeriod), Context -> Try(TimedSchedule(id), [TooManyPeriods, IncompatibleContext, TooManySelectors, InvalidDuration, EmptyWindow, ReversedWindow, OutOfRange, TooManyOverrides, ConflictingEnding(LocalDateTime), ..])

RfcPeriod.Ending : [End(RfcDateTime), Duration(RfcDuration)]

RfcPeriod.Context : [Utc, Local(ZoneRules)]

RfcPeriod.Error : [Malformed, TooLarge, Start(Error), End(Error), Duration(Error), MixedForms, InvalidPeriod]

RfcTimedRule.profile : Str

RfcTimedRule.parse : Parts -> Try(RfcTimedRule, Error)

RfcTimedRule.schedule : id, RfcTimedRule, Window, Context -> Try(TimedSchedule(id), [IncompatibleContext, TooManyPeriods, TooManySelectors, InvalidDuration, EmptyWindow, ReversedWindow, OutOfRange, TooManyOverrides, ConflictingEnding(LocalDateTime), ..])

RfcTimedRule.fact_count : RfcTimedRule -> U64

RfcTimedRule.fact_at : RfcTimedRule, U64 -> [End, Item(SemanticFact)]

RfcTimedRule.to_inspect : RfcTimedRule -> Str

RfcTimedRule.Mode : [Utc, Floating, Zoned]

RfcTimedRule.Parts : { start : Str, rule : Str, duration : Str, inclusions : List(Str), exclusions : List(Str), periods : List(Str), mode : Mode }

RfcTimedRule.Error : [TooLarge, DateTime(Str, Error), Duration(Error), Period(Error), Rule(Error), Incompatible(Str), Unsupported(Str), InvalidRule([InvalidInterval, TooManySelectors, InvalidSelector(Str), InvalidCombination(Str), OutOfRange, InvalidHour, InvalidMinute, InvalidSecond, UnsupportedLeapSecond, InvalidCount, InvalidUntil, InvalidSetPosition, UnsynchronizedStart])]

SemanticFact.new : Kind -> SemanticFact

SemanticFact.kind : SemanticFact -> Kind

SemanticFact.summary : SemanticFact -> Str

SemanticFact.is_eq : SemanticFact, SemanticFact -> Bool

SemanticFact.to_inspect : SemanticFact -> Str

SemanticFact.Resolution : [Year, Month, Day, Hour, Minute, Second, Fraction(U8)]

SemanticFact.Offset : [UnassertedUtc, Asserted(FixedOffset)]

SemanticFact.CalendarData : { kind : [CalendarValue, QualifiedCalendarValue, EdtfDate], calendar : Calendar, fields : Fields, clock : Fields, resolution : Resolution, qualification_count : U64 }

SemanticFact.TimestampData : { kind : [OffsetTimestamp, Ixdtf], local : LocalDateTime, fraction_digits : U8, offset : Offset, zone_present : Bool, annotation_count : U64 }

SemanticFact.QualificationData : { scope : [Whole, Year, Month, Day, Hour, Minute, Second, Fraction], qualifier : [Uncertain, Approximate, UncertainApproximate] }

SemanticFact.ZoneData : { critical : Bool, identifier : [Named(Str), Numeric(FixedOffset)] }

SemanticFact.AnnotationData : { critical : Bool, key : Str, value : Str }

SemanticFact.PositionData : { boundary : PosixBoundary, offset : FixedOffset, local : LocalDateTime }

SemanticFact.ContextData : { name : Str, version : Str, validity : PosixSpan, provenance : [Supplied, DatabaseSource({ requested_name : Str, canonical_name : Str, source_digest : Str, profile : Str })] }

SemanticFact.ExactIntervalData : { span : PosixSpan }

SemanticFact.OffsetEndpointData : { role : [Start, End], local : LocalDateTime, fraction_digits : U8, offset : Offset }

SemanticFact.RfcDateTimeData : { role : [Standalone, Start, End], local : LocalDateTime, form : [Utc, Local] }

SemanticFact.RfcDurationData : { role : [Standalone, PeriodEnding, RecurrenceEnding], days : I64, seconds : I64 }

SemanticFact.RfcPeriodData : { form : [Utc, Local], start : LocalDateTime, ending : [Endpoint(LocalDateTime), Duration({ days : I64, seconds : I64 })] }

SemanticFact.CoverageData : { member_count : U64 }

SemanticFact.CoverageMemberData : { index : U64, span : PosixSpan }

SemanticFact.CivilBoundaryData : { source : LocalDateTime, policy : [RequireUnique, First, Last, MatchingOffset(FixedOffset)], boundary : PosixBoundary, offset : FixedOffset }

SemanticFact.CivilSelectionData : { start : LocalDateTime, end : LocalDateTime, member_count : U64 }

SemanticFact.LocalSelectionData : { start : LocalDateTime, end : LocalDateTime }

SemanticFact.SelectionEvaluationData : { status : [Complete, Limited([WorkLimit, BufferLimit])], segments : U64, buffered : U64 }

SemanticFact.Weekday : [Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday]

SemanticFact.RecurrenceAnchor : [Date(GregorianDate), Local(LocalDateTime)]

SemanticFact.RecurrenceFrequency : [Daily, Weekly, Monthly, Yearly, Hourly, Minutely, Secondly]

SemanticFact.RecurrenceData : { kind : [DateRecurrence, TimedRecurrence], anchor : RecurrenceAnchor, frequency : RecurrenceFrequency, interval : I64, week_start : [None, Some(Weekday)], selector_count : U64, inclusion_count : U64, exclusion_count : U64 }

SemanticFact.RecurrenceEnd : [Forever, Count(U64), UntilDate(GregorianDate), UntilLocal(LocalDateTime), UntilBoundary(PosixBoundary)]

SemanticFact.Selector : [Month(U8), MonthDay(I8), YearDay(I16), WeekNo(I8), Weekday({ ordinal : I8, weekday : Weekday }), SetPosition(I16), Hour(U8), Minute(U8), Second(U8), Microsecond(U32)]

SemanticFact.RecurrenceExceptionData : { kind : [Inclusion, Exclusion], source : RecurrenceAnchor }

SemanticFact.RecurrencePolicyData : { context : [Required, FixedUtc], occurrence : [CallerSupplied, First], gap : [CallerSupplied, UseOffsetBeforeGap] }

SemanticFact.RfcTimedRuleData : { mode : [Utc, Floating, Zoned], period_count : U64 }

SemanticFact.Kind : [RecurrenceDescription(RecurrenceData), RecurrenceTermination(RecurrenceEnd), RecurrenceSelector(Selector), RecurrenceException(RecurrenceExceptionData), RecurrencePolicy(RecurrencePolicyData), RfcTimedRuleDescription(RfcTimedRuleData), CoverageDescription(CoverageData), CoverageMember(CoverageMemberData), CivilBoundaryDescription(CivilBoundaryData), CivilSelectionDescription(CivilSelectionData), LocalSelectionDescription(LocalSelectionData), SelectionEvaluation(SelectionEvaluationData), ExactIntervalDescription(ExactIntervalData), OffsetEndpoint(OffsetEndpointData), RfcDateTimeDescription(RfcDateTimeData), RfcDurationDescription(RfcDurationData), RfcPeriodDescription(RfcPeriodData), CalendarDescription(CalendarData), TimestampDescription(TimestampData), Qualification(QualificationData), Requirement([ZoneContext, UncertaintyModel]), ZoneAnnotation(ZoneData), Annotation(AnnotationData), ResolvedPosition(PositionData), Context(ContextData), Presentation([Gregorian, UnsupportedCalendar(Str)])]

SubdailyPattern.new : { date : GregorianDate, clock : ClockTime }, Spec -> Try(SubdailyPattern, [InvalidInterval, TooManySelectors, InvalidSelector(Str), InvalidCombination(Str), InvalidHour, InvalidMinute, InvalidSecond, UnsupportedLeapSecond, ..])

SubdailyPattern.definition : SubdailyPattern -> { frequency : Frequency, interval : I64, calendar : Spec }

SubdailyPattern.clocks : SubdailyPattern -> ClockPattern

SubdailyPattern.matches_date : SubdailyPattern, GregorianDate -> Try(Bool, [OutOfRange, ..])

SubdailyPattern.period : SubdailyPattern, U64 -> Try(Period, [OutOfRange, ..])

SubdailyPattern.starts_before : SubdailyPattern, U64, LocalDateTime -> Bool

SubdailyPattern.to_inspect : SubdailyPattern -> Str

SubdailyPattern.Frequency : [Hourly, Minutely, Secondly]

SubdailyPattern.Spec : { frequency : Frequency, interval : I64, calendar : Spec, clocks : Spec }

SubdailyPattern.Period : { date : GregorianDate, start_index : U64, end_index : U64, end : LocalDateTime }

TimedOccurrence.validate_duration : Duration -> Try({ }, [InvalidDuration, ..])

TimedOccurrence.cursor : id, Occurrence, Duration -> Try(Cursor(id), [InvalidDuration, OutOfRange, OutsideValidity, InvalidDestination(Fields), ..])

TimedOccurrence.cursor_with_ending : id, Occurrence, Ending -> Try(Cursor(id), [InvalidDuration, OutOfRange, OutsideValidity, InvalidDestination(Fields), ..])

TimedOccurrence.id : TimedOccurrence(id) -> id

TimedOccurrence.start : TimedOccurrence(id) -> Occurrence

TimedOccurrence.ending : TimedOccurrence(id) -> Ending

TimedOccurrence.duration : TimedOccurrence(id) -> [None, Some(Duration)]

TimedOccurrence.span : TimedOccurrence(id) -> PosixSpan

TimedOccurrence.calendar_anchor : TimedOccurrence(id) -> [None, Some({ source : LocalDateTime, choice : BoundaryChoice })]

TimedOccurrence.to_inspect : TimedOccurrence(id) -> Str

TimedOccurrence.Ending : [After(Duration), AtBoundary(PosixBoundary), AtLocal(LocalEnd)]

TimedOccurrence.LocalEnd : { source : LocalDateTime, occurrence : OccurrencePolicy, gap : [RejectGap, UseOffsetBeforeGap] }

TimedOccurrence.Duration : [Coordinate(PosixDelta), Calendar(CalendarDuration)]

TimedOccurrence.CalendarDuration : { delta : CalendarDelta, invalid_date : Policy, tail : PosixDelta, occurrence : OccurrencePolicy, gap : [RejectGap, UseOffsetBeforeGap] }

TimedOccurrence.Batch : { segments : U64, buffered : U64, status : [Complete(TimedOccurrence(id)), Limited({ cursor : Cursor(id), reason : [WorkLimit, BufferLimit] })] }

TimedOccurrence.Cursor

TimedOccurrence.Cursor.collect : Cursor(id), ClassificationLimits -> Try(Batch(id), [InvalidDuration, OutOfRange, Gap, Ambiguous, AmbiguousGap, OffsetConflict, ..])

TimedOccurrence.Cursor.to_inspect : Cursor(id) -> Str

TimedRecurrence.new : { date : GregorianDate, clock : ClockTime }, Spec -> Try(TimedRecurrence, [InvalidInterval, TooManySelectors, InvalidSelector(Str), InvalidCombination(Str), OutOfRange, InvalidHour, InvalidMinute, InvalidSecond, UnsupportedLeapSecond, InvalidCount, InvalidUntil, InvalidSetPosition, UnsynchronizedStart, ..])

TimedRecurrence.new_subdaily : { date : GregorianDate, clock : ClockTime }, SubdailySpec -> Try(TimedRecurrence, [InvalidInterval, TooManySelectors, InvalidSelector(Str), InvalidCombination(Str), OutOfRange, InvalidHour, InvalidMinute, InvalidSecond, UnsupportedLeapSecond, InvalidCount, InvalidUntil, InvalidSetPosition, UnsynchronizedStart, ..])

TimedRecurrence.with_exclusions : TimedRecurrence, List(LocalDateTime) -> Try(TimedRecurrence, [TooManySelectors, ..])

TimedRecurrence.with_inclusions : TimedRecurrence, List({ date : GregorianDate, clock : ClockTime }) -> Try(TimedRecurrence, [TooManySelectors, ..])

TimedRecurrence.add_inclusions : TimedRecurrence, List({ date : GregorianDate, clock : ClockTime }) -> Try(TimedRecurrence, [TooManySelectors, ..])

TimedRecurrence.fact_count : TimedRecurrence -> U64

TimedRecurrence.fact_at : TimedRecurrence, U64 -> [End, Item(SemanticFact)]

TimedRecurrence.to_inspect : TimedRecurrence -> Str

TimedRecurrence.cursor : TimedRecurrence, Window, Context -> Try(Cursor, [EmptyWindow, ReversedWindow, OutOfRange, ..])

TimedRecurrence.Termination : [Forever, Count(U64), Until(LocalDateTime), UntilBoundary(PosixBoundary)]

TimedRecurrence.Spec : { calendar : Spec, clocks : Spec, termination : Termination, by_set_pos : List(I16) }

TimedRecurrence.SubdailySpec : { pattern : Spec, termination : Termination, by_set_pos : List(I16) }

TimedRecurrence.Window : { start : LocalDateTime, end : LocalDateTime }

TimedRecurrence.Context : { rules : ZoneRules, occurrence : OccurrencePolicy, gap : [RejectGap, UseOffsetBeforeGap] }

TimedRecurrence.Limits : { max_steps : U64, max_buffered : U64, max_zone_segments : U64, max_zone_candidates : U64 }

TimedRecurrence.Limit : [WorkLimit, BufferLimit, ZoneWorkLimit, ZoneBufferLimit, OutputLimit]

TimedRecurrence.Occurrence

TimedRecurrence.Occurrence.source : Occurrence -> LocalDateTime

TimedRecurrence.Occurrence.boundary : Occurrence -> PosixBoundary

TimedRecurrence.Occurrence.adjustment : Occurrence -> [Exact, BeforeGap(GapTransition)]

TimedRecurrence.Occurrence.rules : Occurrence -> ZoneRules

TimedRecurrence.Occurrence.to_inspect : Occurrence -> Str

TimedRecurrence.Next : { steps : U64, zone_segments : U64, buffered : U64, zone_buffered : U64, status : [End, Item({ occurrence : Occurrence, cursor : Cursor }), Limited({ cursor : Cursor, reason : Limit })] }

TimedRecurrence.CollectLimits : { work : Limits, max_occurrences : U64 }

TimedRecurrence.Batch : { occurrences : List(Occurrence), steps : U64, zone_segments : U64, buffered : U64, zone_buffered : U64, status : [Complete, Limited({ cursor : Cursor, reason : Limit })] }

TimedRecurrence.Cursor

TimedRecurrence.Cursor.next : Cursor, Limits -> Try(Next, [OutOfRange, OutsideValidity, Gap, Ambiguous, AmbiguousGap, OffsetConflict, UnsynchronizedStart, ..])

TimedRecurrence.Cursor.collect : Cursor, CollectLimits -> Try(Batch, [OutOfRange, OutsideValidity, Gap, Ambiguous, AmbiguousGap, OffsetConflict, UnsynchronizedStart, ..])

TimedRecurrence.Cursor.outcomes : Cursor, Limits -> Iter(Try(Next, [OutOfRange, OutsideValidity, Gap, Ambiguous, AmbiguousGap, OffsetConflict, UnsynchronizedStart]))

TimedRecurrence.Cursor.to_inspect : Cursor -> Str

TimedSchedule.new : id, TimedRecurrence, Window, Duration, Context -> Try(TimedSchedule(id), [InvalidDuration, EmptyWindow, ReversedWindow, OutOfRange, ..])

TimedSchedule.new_with_overrides : id, TimedRecurrence, Window, Duration, List(Override), Context -> Try(TimedSchedule(id), [InvalidDuration, EmptyWindow, ReversedWindow, OutOfRange, TooManyOverrides, ConflictingDuration(LocalDateTime), ..])

TimedSchedule.new_with_endings : id, TimedRecurrence, Window, Duration, List(EndOverride), Context -> Try(TimedSchedule(id), [InvalidDuration, EmptyWindow, ReversedWindow, OutOfRange, TooManyOverrides, ConflictingEnding(LocalDateTime), ..])

TimedSchedule.next : TimedSchedule(id), Limits -> Try(Next(id), Error)

TimedSchedule.collect : TimedSchedule(id), { work : Limits, max_occurrences : U64 } -> Try(Batch(id), Error)

TimedSchedule.outcomes : TimedSchedule(id), Limits -> Iter(Try(Next(id), Error))

TimedSchedule.to_inspect : TimedSchedule(id) -> Str

TimedSchedule.EndOverride : { source : LocalDateTime, ending : Ending }

TimedSchedule.Override : { source : LocalDateTime, duration : Duration }

TimedSchedule.Limits : Limits

TimedSchedule.Limit : [StartWorkLimit, StartBufferLimit, StartZoneWorkLimit, StartZoneBufferLimit, EndZoneWorkLimit, EndZoneBufferLimit, OutputLimit]

TimedSchedule.Next : { steps : U64, zone_segments : U64, start_buffered : U64, start_zone_buffered : U64, end_buffered : U64, status : [End, Item({ occurrence : TimedOccurrence({ series : id, source : LocalDateTime }), cursor : TimedSchedule(id) }), Limited({ cursor : TimedSchedule(id), reason : Limit })] }

TimedSchedule.Batch : { occurrences : List(TimedOccurrence({ series : id, source : LocalDateTime })), steps : U64, zone_segments : U64, status : [Complete, Limited({ cursor : TimedSchedule(id), reason : Limit })] }

TimedSchedule.Error : [InvalidDuration, OutOfRange, OutsideValidity, InvalidDestination(Fields), Gap, Ambiguous, AmbiguousGap, OffsetConflict, UnsynchronizedStart]

ZoneRules.new : Str, Str, PosixSpan, FixedOffset, List(Transition) -> Try(ZoneRules, [EmptyName, EmptyVersion, TransitionOutsideValidity, UnorderedTransitions, InvalidOffsetBounds, OffsetOutsideBounds, ..])

ZoneRules.new_bounded : Str, Str, PosixSpan, FixedOffset, List(Transition), OffsetBounds -> Try(ZoneRules, [EmptyName, EmptyVersion, TransitionOutsideValidity, UnorderedTransitions, InvalidOffsetBounds, OffsetOutsideBounds, ..])

ZoneRules.definition : ZoneRules -> Definition

ZoneRules.from_definition : Definition -> Try(ZoneRules, [EmptyName, EmptyVersion, TransitionOutsideValidity, UnorderedTransitions, InvalidOffsetBounds, OffsetOutsideBounds, MissingProvenance, ProvenanceNameMismatch, InvalidDatabaseAlignment, ..])

ZoneRules.from_database : Database -> Try(ZoneRules, [UnsupportedSchema(U16), UnsupportedAxis(Str), UnsupportedFutureHandling(Str), MissingProvenance, EmptyName, EmptyVersion, TransitionOutsideValidity, UnorderedTransitions, InvalidOffsetBounds, OffsetOutsideBounds, EmptySpan, ReversedBounds, OutOfRange, ..])

ZoneRules.provenance : ZoneRules -> Provenance

ZoneRules.name : ZoneRules -> Str

ZoneRules.version : ZoneRules -> Str

ZoneRules.validity : ZoneRules -> PosixSpan

ZoneRules.offset_bounds : ZoneRules -> OffsetBounds

ZoneRules.offset_at : ZoneRules, PosixBoundary -> Try(FixedOffset, [OutsideValidity, ..])

ZoneRules.resolve : ZoneRules, LocalDateTime -> Try(Resolution, [OutsideValidity, OutOfRange, ..])

ZoneRules.classification_cursor : ZoneRules, LocalDateTime -> Try(ClassificationCursor, [OutsideValidity, OutOfRange, ..])

ZoneRules.resolve_occurrence : ZoneRules, LocalDateTime, OccurrencePolicy -> Try(PosixBoundary, [Gap, Ambiguous, OffsetConflict, OutsideValidity, OutOfRange, ..])

ZoneRules.appointment : ZoneRules, LocalDateTime, OccurrencePolicy, LocalDateTime, OccurrencePolicy -> Try(PosixSpan, [Gap, Ambiguous, OffsetConflict, OutsideValidity, OutOfRange, EmptySpan, ReversedBounds, ..])

ZoneRules.select : ZoneRules, LocalDateTime, LocalDateTime -> Try(Coverage, [EmptySelection, ReversedSelection, OutsideValidity, OutOfRange, ..])

ZoneRules.selection_cursor : ZoneRules, LocalDateTime, LocalDateTime -> Try(SelectionCursor, [EmptySelection, ReversedSelection, OutsideValidity, OutOfRange, ..])

ZoneRules.Database : { schema : U16, axis : Str, requested_name : Str, canonical_name : Str, source_version : Str, source_digest : Str, profile : Str, future_handling : Str, start_second : I64, end_second : I64, initial_offset : I32, minimum_offset : I32, maximum_offset : I32, transitions : List({ second : I64, offset : I32 }) }

ZoneRules.Provenance : [Supplied, DatabaseSource({ requested_name : Str, canonical_name : Str, source_digest : Str, profile : Str })]

ZoneRules.Transition : { at : PosixBoundary, offset : FixedOffset }

ZoneRules.OffsetBounds : { minimum : I32, maximum : I32 }

ZoneRules.Definition : { name : Str, version : Str, validity : PosixSpan, initial : FixedOffset, bounds : OffsetBounds, provenance : Provenance, transitions : List(Transition) }

ZoneRules.Resolution : [Gap, Unique(PosixBoundary), Fold(List(PosixBoundary))]

ZoneRules.OccurrencePolicy : [RequireUnique, First, Last, MatchingOffset(FixedOffset)]

ZoneRules.GapTransition : { at : PosixBoundary, before : FixedOffset, after : FixedOffset }

ZoneRules.BoundaryChoice : { boundary : PosixBoundary, adjustment : [Exact, BeforeGap(GapTransition)] }

ZoneRules.Classification

ZoneRules.Classification.resolution : Classification -> Resolution

ZoneRules.Classification.rules : Classification -> ZoneRules

ZoneRules.Classification.local : Classification -> LocalDateTime

ZoneRules.Classification.gap_transitions : Classification -> List(GapTransition)

ZoneRules.Classification.choose : Classification, { occurrence : OccurrencePolicy, gap : [RejectGap, UseOffsetBeforeGap] } -> Try(BoundaryChoice, [Gap, Ambiguous, AmbiguousGap, OffsetConflict, OutOfRange, ..])

ZoneRules.Classification.to_inspect : Classification -> Str

ZoneRules.ClassificationLimits : { max_segments : U64, max_candidates : U64 }

ZoneRules.ClassificationBatch : { segments : U64, buffered : U64, status : [Complete(Classification), Limited({ cursor : ClassificationCursor, reason : [WorkLimit, BufferLimit] })] }

ZoneRules.ClassificationCursor

ZoneRules.ClassificationCursor.collect : ClassificationCursor, ClassificationLimits -> Try(ClassificationBatch, [OutOfRange, ..])

ZoneRules.ClassificationCursor.to_inspect : ClassificationCursor -> Str

ZoneRules.SelectionLimits : { max_segments : U64, max_members : U64 }

ZoneRules.SelectionBatch : { segments : U64, buffered : U64, status : [Complete(Coverage), Limited({ cursor : SelectionCursor, reason : [WorkLimit, BufferLimit] })] }

ZoneRules.SelectionCursor

ZoneRules.SelectionCursor.context : SelectionCursor -> { rules : ZoneRules, start : LocalDateTime, end : LocalDateTime }

ZoneRules.SelectionCursor.collect : SelectionCursor, SelectionLimits -> Try(SelectionBatch, [OutOfRange, ..])

ZoneRules.SelectionCursor.to_inspect : SelectionCursor -> Str