Struct Notification 

#[non_exhaustive]
pub struct Notification {
    pub event_type: String,
    pub sequence: u64,
    pub identifier: BTreeMap<String, String>,
    pub payload: Value,
    pub cloudevent: Option<Value>,
}

A notification received from the server.

Constructed from the wire-format CloudEvent envelope, which is hidden per D9. New envelope fields will appear here as the streaming surface lands; the type is #[non_exhaustive] so additions do not break downstream code.

Serialize is derived so trigger dispatchers (and any downstream consumer) can render the notification as JSON without bespoke serialisation code. The wire shape on serialisation is the public field layout: event_type, sequence, identifier, payload.

The SSE watch stream does NOT carry a per-notification request_id correlation field; the sequence is the stream-level correlation identifier (monotonic, server-assigned, suitable for resume cursors). The session-level X-Request-ID returned when a watch is opened is emitted as a client.watch.subscribed tracing event from the supervisor; that is the value to quote in support tickets for a running watch.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

event_type: String

Schema event-type, parsed from the CloudEvent id (the part before @).

sequence: u64

Per-stream monotonic sequence, parsed from the CloudEvent id (the part after @).

identifier: BTreeMap<String, String>

Identifier key/value pairs as published.

payload: Value

Payload as published. JSON null is preserved as serde_json::Value::Null.

cloudevent: Option<Value>

Raw CloudEvent envelope as the server emitted it on the SSE wire, preserved verbatim (parsed as JSON, never re-serialised through a schema-narrowing intermediate). Some in the production watch path (the supervisor captures the envelope before narrowing to the lib’s internal fields); None when the notification was synthesised outside the watch path (test fixtures, library callers building notifications directly).

Triggers needing the exact server-emitted envelope (post trigger, any future CloudEvent-aware forwarder) MUST read this field rather than reconstructing one from the other fields, because the lib otherwise discards envelope metadata (D9: CloudEvent envelope hidden) and a reconstruction would synthesise values for time, source, type that do not match the server’s actual emission.

The field is #[serde(skip)] so the published serialisation of Notification (echo trigger output, log trigger lines, default webhook body, the AVISO_NOTIFICATION_JSON env var the command trigger injects) keeps the historical 4-field shape. Consumers reading this field by name on the public Rust struct are the supported access path; JSON consumers should not expect to see it on the wire.

Trait Implementations

impl Clone for Notification

fn clone(&self) -> Notification

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Notification

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

Formats the value using the given formatter.

impl Eq for Notification

impl PartialEq for Notification

fn eq(&self, other: &Notification) -> 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 Notification

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Notification