Enum TemporalExpressionType 

pub enum TemporalExpressionType {
    Absolute,
    Relative {
        offset_days: i32,
        anchor: Option<Box<DateTime<Utc>>>,
    },
    EventAnchored {
        event: String,
        relation: TemporalRelation,
    },
    Recurring {
        pattern: String,
        frequency: Option<RecurrenceFrequency>,
    },
    Fuzzy {
        direction: FuzzyDirection,
        approximate_days: Option<(i32, i32)>,
    },
    Partial {
        specified: PartialTimeComponents,
    },
}

Type of temporal expression based on how it relates to absolute time.

┌─────────────────────────────────────────────────────────────────────┐
│                    TEMPORAL EXPRESSION TYPES                        │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  Absolute:    "January 15, 2024"     → directly mappable            │
│  Relative:    "yesterday", "next week" → needs document date        │
│  Anchored:    "before the war"       → needs event reference        │
│  Recurring:   "every Monday"         → pattern, not single point    │
│  Fuzzy:       "recently", "soon"     → vague, probabilistic         │
│  Partial:     "in the morning"       → missing date component       │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

Variants

Absolute

Directly maps to calendar time: “2024-01-15”, “January 2024”

Relative

Relative to document/utterance time: “yesterday”, “next week”, “3 days ago”

Fields

offset_days: i32

Direction from anchor (negative = past, positive = future)

anchor: Option<Box<DateTime<Utc>>>

The reference point (if known)

EventAnchored

Anchored to an event rather than calendar: “before the war”, “after graduation”

Fields

event: String

The anchor event description

relation: TemporalRelation

Temporal relation to the event

Recurring

Recurring pattern: “every Monday”, “annually”, “on weekends”

Fields

pattern: String

Pattern description

frequency: Option<RecurrenceFrequency>

Frequency (if extractable)

Fuzzy

Fuzzy/vague: “recently”, “soon”, “in the past”, “long ago”

Fields

direction: FuzzyDirection

Direction (past/future/unknown)

approximate_days: Option<(i32, i32)>

Approximate distance (if inferable)

Partial

Partial specification: “in the morning”, “on Tuesday” (missing year/date)

Fields

specified: PartialTimeComponents

What components are specified

Trait Implementations

impl Clone for TemporalExpressionType

fn clone(&self) -> TemporalExpressionType

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TemporalExpressionType

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TemporalExpressionType

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for TemporalExpressionType

fn eq(&self, other: &TemporalExpressionType) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for TemporalExpressionType

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for TemporalExpressionType

impl StructuralPartialEq for TemporalExpressionType