Enum AlertTrigger 

#[non_exhaustive]
pub enum AlertTrigger {
    OffsetTrigger(OffsetTrigger),
    AbsoluteTrigger(AbsoluteTrigger),
    Unknown(Value),
}

Alert trigger — either offset-based, absolute, or an unknown future type (RFC 8984 §4.5.2).

The @type field on the wire selects the variant. The Unknown variant preserves any unrecognised trigger type for round-trip fidelity, as required by the spec: “Implementations MUST NOT trigger for trigger types they do not understand but MUST preserve them.”

Serde is implemented manually because #[serde(tag = "@type", other)] with a tuple variant is not supported by serde’s derive macros; other only works with unit variants in internally-tagged enums.

Deserialization behaviour on malformed input

The custom Deserialize impl is deliberately permissive about the JSON shape of the input — only the @type tag drives the dispatch. Any input whose @type is missing, is not a string, or names a tag other than "OffsetTrigger" / "AbsoluteTrigger" is captured as AlertTrigger::Unknown carrying the original serde_json::Value unchanged. This includes:

• top-level non-objects: null, arrays, numbers, strings, booleans
• objects without an @type key
• objects whose @type is a non-string value (null, 42, [])
• objects whose @type is a string outside the known set

The rationale is round-trip fidelity per the spec’s preserve-mandate: rejecting at deserialize time would force consumers to drop data they are supposed to preserve. Consumers that need a stricter check should pattern-match on the variant and inspect the carried Value. A future well-typed AlertTrigger variant only ever displaces input that previously matched on @type exactly, so this permissive behaviour is forward-compatible with the spec’s evolution.

Maintainer note: do NOT “clean up” this enum

The Unknown(serde_json::Value) variant exists because RFC 8984 §4.5.2 requires preservation of unrecognised trigger types. The following three “cleanups” all violate that MUST and break the regression tests alert_trigger_unknown_dispatch_on_hostile_input and alert_trigger_unknown_round_trips_through_serialize (both in this file), as well as alert_unknown_trigger_roundtrip in crate-jmap-calendars-types/tests/types_test.rs:

1. Remove the Unknown variant. An exhaustive enum forces deserialize to either fail on an unknown @type (data loss + error) or silently drop the input (data loss). Both violate MUST preserve them.

2. Replace Unknown(Value) with #[serde(other)] on a unit variant. A unit variant discards the carried JSON payload. The spec preserve- mandate requires the bytes round-trip, not just the variant discriminator. Unknown(String) and Unknown { at_type: String } have the same defect — they drop the inner fields.

3. Add #[serde(deny_unknown_fields)] to AlertTrigger or to OffsetTrigger / AbsoluteTrigger. A peer that emits an extension field on a known trigger type (e.g. OffsetTrigger with a vendor field) would fail to deserialize entirely. The catch-all extra map on the inner structs is the workspace’s extras-preservation mechanism for that case; deny_unknown_fields fights it.

If you are reading this comment because you have a fourth “cleanup” in mind: confirm against the regression test and the spec passage (RFC 8984 §4.5.2) before proposing it. The design defense is bd:JMAP-1rwf.8.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

OffsetTrigger(OffsetTrigger)

Offset-based trigger: fires at offset relative to event start/end.

AbsoluteTrigger(AbsoluteTrigger)

Absolute trigger: fires at a specific UTC date-time.

Unknown(Value)

Any other trigger type; preserved opaquely as raw JSON.

Trait Implementations

impl Clone for AlertTrigger

fn clone(&self) -> AlertTrigger

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AlertTrigger

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AlertTrigger

fn deserialize<D>(d: D) -> Result<AlertTrigger, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for AlertTrigger

impl PartialEq for AlertTrigger

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for AlertTrigger

fn serialize<S>( &self, s: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for AlertTrigger