Struct EventRegistrationRequest 

pub struct EventRegistrationRequest {
    pub schema_version: String,
    pub handles: Option<TransactionHandles>,
    pub transaction_id: Option<String>,
    pub client_metadata: Option<ClientMetadata>,
    pub event_type: Option<EventType>,
    pub transaction_event_filter: Option<TransactionEvent>,
}

Request to register a receipt with the Versa registry.

This is the first step in sending a receipt through Versa. The registry will respond with encryption keys and receiver endpoints.

Example

use versa::protocol::{EventRegistrationRequest, TransactionHandles, event::EventType};

let request = EventRegistrationRequest {
    event_type: Some(EventType::Receipt),
    schema_version: "2.1.1".to_string(),
    handles: Some(TransactionHandles::new()
        .with_customer_email("customer@example.com".to_string())),
    transaction_id: None,
    client_metadata: None,
    transaction_event_filter: None,
};

Fields

schema_version: String

The schema version of the receipt (e.g., “2.1.1”)

handles: Option<TransactionHandles>

Provide as many handles as available to ensure the receipt is routed to the correct receivers

transaction_id: Option<String>

The Versa Transaction ID, if updating an existing receipt

client_metadata: Option<ClientMetadata>

Client software metadata, such as the client_string

event_type: Option<EventType>

Specify the event type for this registration. If left blank, the registry will default to ‘receipt’

transaction_event_filter: Option<TransactionEvent>

Filter receivers by the specific transaction event data you are prepared to send

Trait Implementations

impl Debug for EventRegistrationRequest

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EventRegistrationRequest

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for EventRegistrationRequest

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

where __S: Serializer,

Serialize this value into the given Serde serializer.