1#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)]
2pub struct RemoteTriggerOccurrenceRequest {
3 pub protocol_version: u32,
4 pub source_type: String,
5 pub source_key: String,
6 #[serde(default)]
7 pub payload: serde_json::Value,
8 pub idempotency_key: String,
9 #[serde(default, skip_serializing_if = "Option::is_none")]
10 pub source: Option<serde_json::Value>,
11}
12
13impl RemoteTriggerOccurrenceRequest {
14 pub fn new(
15 source_type: impl Into<String>,
16 source_key: impl Into<String>,
17 payload: serde_json::Value,
18 idempotency_key: impl Into<String>,
19 ) -> Self {
20 Self {
21 protocol_version: REMOTE_PROTOCOL_VERSION,
22 source_type: source_type.into(),
23 source_key: source_key.into(),
24 payload,
25 idempotency_key: idempotency_key.into(),
26 source: None,
27 }
28 }
29
30 pub fn with_source(mut self, source: serde_json::Value) -> Self {
31 self.source = Some(source);
32 self
33 }
34
35 pub fn validate(&self) -> Result<(), RemoteProtocolError> {
36 ensure_protocol_version(self.protocol_version)?;
37 require_non_empty(
38 "RemoteTriggerOccurrenceRequest",
39 "source_type",
40 &self.source_type,
41 )?;
42 require_non_empty(
43 "RemoteTriggerOccurrenceRequest",
44 "source_key",
45 &self.source_key,
46 )?;
47 require_non_empty(
48 "RemoteTriggerOccurrenceRequest",
49 "idempotency_key",
50 &self.idempotency_key,
51 )
52 }
53}
54
55#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)]
56pub struct RemoteTriggerOccurrenceRecord {
57 pub occurrence_id: String,
58 pub source_type: String,
59 pub source_key: String,
60 #[serde(default)]
61 pub payload: serde_json::Value,
62 pub idempotency_key: String,
63 #[serde(default, skip_serializing_if = "Option::is_none")]
64 pub source: Option<serde_json::Value>,
65 pub occurred_at_ms: u64,
66}
67
68#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
69pub struct RemoteTriggerEmitReport {
70 pub protocol_version: u32,
71 #[serde(default, skip_serializing_if = "String::is_empty")]
72 pub occurrence_id: String,
73 #[serde(default, skip_serializing_if = "Vec::is_empty")]
74 pub started_process_ids: Vec<String>,
75}
76
77impl RemoteTriggerEmitReport {
78 pub fn validate(&self) -> Result<(), RemoteProtocolError> {
79 ensure_protocol_version(self.protocol_version)
80 }
81}
82
83#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)]
84pub struct RemoteTriggerSubscriptionFilter {
85 pub protocol_version: u32,
86 #[serde(default, skip_serializing_if = "Option::is_none")]
87 pub session_id: Option<String>,
88 #[serde(default, skip_serializing_if = "Option::is_none")]
89 pub handle: Option<String>,
90 #[serde(default, skip_serializing_if = "Option::is_none")]
91 pub name: Option<String>,
92 #[serde(default, skip_serializing_if = "Option::is_none")]
93 pub source_type: Option<String>,
94 #[serde(default, skip_serializing_if = "Option::is_none")]
95 pub source_key: Option<String>,
96 #[serde(default, skip_serializing_if = "Option::is_none")]
97 pub target: Option<RemoteProcessDefinitionIdentity>,
98 #[serde(default, skip_serializing_if = "Option::is_none")]
99 pub enabled: Option<bool>,
100}
101
102impl Default for RemoteTriggerSubscriptionFilter {
103 fn default() -> Self {
104 Self {
105 protocol_version: REMOTE_PROTOCOL_VERSION,
106 session_id: None,
107 handle: None,
108 name: None,
109 source_type: None,
110 source_key: None,
111 target: None,
112 enabled: None,
113 }
114 }
115}
116
117impl RemoteTriggerSubscriptionFilter {
118 pub fn for_session(session_id: impl Into<String>) -> Self {
119 Self {
120 protocol_version: REMOTE_PROTOCOL_VERSION,
121 session_id: Some(session_id.into()),
122 ..Self::default()
123 }
124 }
125
126 pub fn for_source_type(source_type: impl Into<String>) -> Self {
127 Self {
128 protocol_version: REMOTE_PROTOCOL_VERSION,
129 source_type: Some(source_type.into()),
130 ..Self::default()
131 }
132 }
133
134 pub fn validate(&self) -> Result<(), RemoteProtocolError> {
135 ensure_protocol_version(self.protocol_version)
136 }
137}
138
139#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)]
140pub struct RemoteTriggerRegistration {
141 pub handle: String,
142 pub source_key: String,
143 #[serde(default, skip_serializing_if = "Option::is_none")]
144 pub name: Option<String>,
145 pub source_type: String,
146 #[serde(default)]
147 pub source: serde_json::Value,
148 pub target: RemoteTriggerTargetSummary,
149 #[serde(default = "default_true")]
150 pub enabled: bool,
151}
152
153#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)]
154pub struct RemoteTriggerTargetSummary {
155 pub process_name: String,
156 #[serde(default)]
157 pub inputs: RemoteTriggerInputTemplate,
158}
159
160fn default_true() -> bool {
161 true
162}
163
164#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, JsonSchema)]
165#[serde(transparent)]
166pub struct RemoteTriggerInputTemplate {
167 pub entries: BTreeMap<String, RemoteTriggerInputBinding>,
168}
169
170impl RemoteTriggerInputTemplate {
171 pub fn new(entries: BTreeMap<String, RemoteTriggerInputBinding>) -> Self {
172 Self { entries }
173 }
174
175 pub fn validate(&self, type_name: &'static str) -> Result<(), RemoteProtocolError> {
176 for name in self.entries.keys() {
177 require_non_empty(type_name, "input_template key", name)?;
178 }
179 Ok(())
180 }
181}
182
183#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)]
184#[serde(tag = "kind", rename_all = "snake_case")]
185pub enum RemoteTriggerInputBinding {
186 Event,
187 Fixed { value: serde_json::Value },
188}
189
190#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)]
191pub struct RemoteTriggerSubscriptionDraft {
192 pub protocol_version: u32,
193 pub registrant: RemoteProcessOriginator,
194 pub env_ref: String,
195 #[serde(default, skip_serializing_if = "Option::is_none")]
196 pub wake_target: Option<RemoteSessionScope>,
197 #[serde(default, skip_serializing_if = "Option::is_none")]
198 pub name: Option<String>,
199 pub source_type: String,
200 pub source_key: String,
201 #[serde(default)]
202 pub source: serde_json::Value,
203 #[serde(default)]
204 pub event_ty: serde_json::Value,
205 pub target: RemoteProcessDefinitionIdentity,
206 #[serde(default)]
207 pub input_template: RemoteTriggerInputTemplate,
208}
209
210impl RemoteTriggerSubscriptionDraft {
211 pub fn validate(&self) -> Result<(), RemoteProtocolError> {
212 ensure_protocol_version(self.protocol_version)?;
213 self.registrant.validate("RemoteTriggerSubscriptionDraft")?;
214 require_non_empty("RemoteTriggerSubscriptionDraft", "env_ref", &self.env_ref)?;
215 if let Some(wake_target) = &self.wake_target {
216 wake_target.validate("RemoteTriggerSubscriptionDraft")?;
217 }
218 require_non_empty(
219 "RemoteTriggerSubscriptionDraft",
220 "source_type",
221 &self.source_type,
222 )?;
223 require_non_empty(
224 "RemoteTriggerSubscriptionDraft",
225 "source_key",
226 &self.source_key,
227 )?;
228 self.target.validate("RemoteTriggerSubscriptionDraft")?;
229 self.input_template
230 .validate("RemoteTriggerSubscriptionDraft")
231 }
232}
233
234#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)]
235pub struct RemoteTriggerSubscriptionRecord {
236 pub subscription_id: String,
237 pub registrant: RemoteProcessOriginator,
238 pub env_ref: String,
239 #[serde(default, skip_serializing_if = "Option::is_none")]
240 pub wake_target: Option<RemoteSessionScope>,
241 pub handle: String,
242 #[serde(default, skip_serializing_if = "Option::is_none")]
243 pub name: Option<String>,
244 pub source_type: String,
245 pub source_key: String,
246 #[serde(default)]
247 pub source: serde_json::Value,
248 #[serde(default)]
249 pub event_ty: serde_json::Value,
250 pub target: RemoteProcessDefinitionIdentity,
251 #[serde(default)]
252 pub input_template: RemoteTriggerInputTemplate,
253 #[serde(default = "default_true")]
254 pub enabled: bool,
255 pub created_at_ms: u64,
256 pub updated_at_ms: u64,
257}
258
259impl RemoteTriggerSubscriptionRecord {
260 pub fn validate(&self, type_name: &'static str) -> Result<(), RemoteProtocolError> {
261 require_non_empty(type_name, "subscription_id", &self.subscription_id)?;
262 self.registrant.validate(type_name)?;
263 require_non_empty(type_name, "env_ref", &self.env_ref)?;
264 if let Some(wake_target) = &self.wake_target {
265 wake_target.validate(type_name)?;
266 }
267 require_non_empty(type_name, "handle", &self.handle)?;
268 require_non_empty(type_name, "source_type", &self.source_type)?;
269 require_non_empty(type_name, "source_key", &self.source_key)?;
270 self.target.validate(type_name)?;
271 self.input_template.validate(type_name)
272 }
273}
274
275#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)]
276pub struct RemoteTriggerRegisterSubscriptionRequest {
277 pub protocol_version: u32,
278 pub draft: RemoteTriggerSubscriptionDraft,
279}
280
281impl RemoteTriggerRegisterSubscriptionRequest {
282 pub fn validate(&self) -> Result<(), RemoteProtocolError> {
283 ensure_protocol_version(self.protocol_version)?;
284 if self.draft.protocol_version != self.protocol_version {
285 return Err(RemoteProtocolError::MismatchedNestedProtocolVersion {
286 parent: "RemoteTriggerRegisterSubscriptionRequest",
287 child: "draft",
288 parent_version: self.protocol_version,
289 child_version: self.draft.protocol_version,
290 });
291 }
292 self.draft.validate()
293 }
294}
295
296#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)]
297pub struct RemoteTriggerRegisterSubscriptionResult {
298 pub protocol_version: u32,
299 pub record: RemoteTriggerSubscriptionRecord,
300}
301
302impl RemoteTriggerRegisterSubscriptionResult {
303 pub fn validate(&self) -> Result<(), RemoteProtocolError> {
304 ensure_protocol_version(self.protocol_version)?;
305 self.record
306 .validate("RemoteTriggerRegisterSubscriptionResult")
307 }
308}
309
310#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, JsonSchema)]
311pub struct RemoteTriggerListSubscriptionsResponse {
312 pub protocol_version: u32,
313 #[serde(default)]
314 pub subscriptions: Vec<RemoteTriggerSubscriptionRecord>,
315}
316
317impl RemoteTriggerListSubscriptionsResponse {
318 pub fn validate(&self) -> Result<(), RemoteProtocolError> {
319 ensure_protocol_version(self.protocol_version)?;
320 for record in &self.subscriptions {
321 record.validate("RemoteTriggerListSubscriptionsResponse")?;
322 }
323 Ok(())
324 }
325}
326
327#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
328pub struct RemoteTriggerCancelSubscriptionRequest {
329 pub protocol_version: u32,
330 pub session_id: String,
331 pub handle: String,
332}
333
334impl RemoteTriggerCancelSubscriptionRequest {
335 pub fn validate(&self) -> Result<(), RemoteProtocolError> {
336 ensure_protocol_version(self.protocol_version)?;
337 require_non_empty(
338 "RemoteTriggerCancelSubscriptionRequest",
339 "session_id",
340 &self.session_id,
341 )?;
342 require_non_empty(
343 "RemoteTriggerCancelSubscriptionRequest",
344 "handle",
345 &self.handle,
346 )
347 }
348}
349
350#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
351pub struct RemoteTriggerCancelSubscriptionResult {
352 pub protocol_version: u32,
353 pub session_id: String,
354 pub handle: String,
355 pub cancelled: bool,
356}
357
358impl RemoteTriggerCancelSubscriptionResult {
359 pub fn validate(&self) -> Result<(), RemoteProtocolError> {
360 ensure_protocol_version(self.protocol_version)?;
361 require_non_empty(
362 "RemoteTriggerCancelSubscriptionResult",
363 "session_id",
364 &self.session_id,
365 )?;
366 require_non_empty(
367 "RemoteTriggerCancelSubscriptionResult",
368 "handle",
369 &self.handle,
370 )
371 }
372}