zbrox.com
1// @generated by jacquard-lexicon. DO NOT EDIT.
2//
3// Lexicon: tools.ozone.moderation.defs
4//
5// This file was automatically generated from Lexicon schemas.
6// Any manual changes will be overwritten on the next regeneration.
7
8pub mod emit_event;
9pub mod get_account_timeline;
10pub mod get_event;
11pub mod get_record;
12pub mod get_records;
13pub mod get_repo;
14pub mod get_reporter_stats;
15pub mod get_repos;
16pub mod get_subjects;
17pub mod query_events;
18pub mod query_statuses;
19pub mod search_repos;
20
21///Logs account status related events on a repo subject. Normally captured by automod from the firehose and emitted to ozone for historical tracking.
22#[jacquard_derive::lexicon]
23#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
24#[serde(rename_all = "camelCase")]
25pub struct AccountEvent<'a> {
26 ///Indicates that the account has a repository which can be fetched from the host that emitted this event.
27 pub active: bool,
28 #[serde(skip_serializing_if = "std::option::Option::is_none")]
29 #[serde(borrow)]
30 pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
31 #[serde(skip_serializing_if = "std::option::Option::is_none")]
32 #[serde(borrow)]
33 pub status: std::option::Option<jacquard_common::CowStr<'a>>,
34 pub timestamp: jacquard_common::types::string::Datetime,
35}
36
37impl jacquard_common::IntoStatic for AccountEvent<'_> {
38 type Output = AccountEvent<'static>;
39 fn into_static(self) -> Self::Output {
40 AccountEvent {
41 active: self.active.into_static(),
42 comment: self.comment.into_static(),
43 status: self.status.into_static(),
44 timestamp: self.timestamp.into_static(),
45 extra_data: self.extra_data.into_static(),
46 }
47 }
48}
49
50#[jacquard_derive::lexicon]
51#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
52#[serde(rename_all = "camelCase")]
53pub struct AccountHosting<'a> {
54 #[serde(skip_serializing_if = "std::option::Option::is_none")]
55 pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,
56 #[serde(skip_serializing_if = "std::option::Option::is_none")]
57 pub deactivated_at: std::option::Option<jacquard_common::types::string::Datetime>,
58 #[serde(skip_serializing_if = "std::option::Option::is_none")]
59 pub deleted_at: std::option::Option<jacquard_common::types::string::Datetime>,
60 #[serde(skip_serializing_if = "std::option::Option::is_none")]
61 pub reactivated_at: std::option::Option<jacquard_common::types::string::Datetime>,
62 #[serde(borrow)]
63 pub status: jacquard_common::CowStr<'a>,
64 #[serde(skip_serializing_if = "std::option::Option::is_none")]
65 pub updated_at: std::option::Option<jacquard_common::types::string::Datetime>,
66}
67
68impl jacquard_common::IntoStatic for AccountHosting<'_> {
69 type Output = AccountHosting<'static>;
70 fn into_static(self) -> Self::Output {
71 AccountHosting {
72 created_at: self.created_at.into_static(),
73 deactivated_at: self.deactivated_at.into_static(),
74 deleted_at: self.deleted_at.into_static(),
75 reactivated_at: self.reactivated_at.into_static(),
76 status: self.status.into_static(),
77 updated_at: self.updated_at.into_static(),
78 extra_data: self.extra_data.into_static(),
79 }
80 }
81}
82
83///Statistics about a particular account subject
84#[jacquard_derive::lexicon]
85#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
86#[serde(rename_all = "camelCase")]
87pub struct AccountStats<'a> {
88 ///Total number of appeals against a moderation action on the account
89 #[serde(skip_serializing_if = "std::option::Option::is_none")]
90 pub appeal_count: std::option::Option<i64>,
91 ///Number of times the account was escalated
92 #[serde(skip_serializing_if = "std::option::Option::is_none")]
93 pub escalate_count: std::option::Option<i64>,
94 ///Total number of reports on the account
95 #[serde(skip_serializing_if = "std::option::Option::is_none")]
96 pub report_count: std::option::Option<i64>,
97 ///Number of times the account was suspended
98 #[serde(skip_serializing_if = "std::option::Option::is_none")]
99 pub suspend_count: std::option::Option<i64>,
100 ///Number of times the account was taken down
101 #[serde(skip_serializing_if = "std::option::Option::is_none")]
102 pub takedown_count: std::option::Option<i64>,
103}
104
105impl jacquard_common::IntoStatic for AccountStats<'_> {
106 type Output = AccountStats<'static>;
107 fn into_static(self) -> Self::Output {
108 AccountStats {
109 appeal_count: self.appeal_count.into_static(),
110 escalate_count: self.escalate_count.into_static(),
111 report_count: self.report_count.into_static(),
112 suspend_count: self.suspend_count.into_static(),
113 takedown_count: self.takedown_count.into_static(),
114 extra_data: self.extra_data.into_static(),
115 }
116 }
117}
118
119///Age assurance info coming directly from users. Only works on DID subjects.
120#[jacquard_derive::lexicon]
121#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
122#[serde(rename_all = "camelCase")]
123pub struct AgeAssuranceEvent<'a> {
124 ///The unique identifier for this instance of the age assurance flow, in UUID format.
125 #[serde(borrow)]
126 pub attempt_id: jacquard_common::CowStr<'a>,
127 ///The IP address used when completing the AA flow.
128 #[serde(skip_serializing_if = "std::option::Option::is_none")]
129 #[serde(borrow)]
130 pub complete_ip: std::option::Option<jacquard_common::CowStr<'a>>,
131 ///The user agent used when completing the AA flow.
132 #[serde(skip_serializing_if = "std::option::Option::is_none")]
133 #[serde(borrow)]
134 pub complete_ua: std::option::Option<jacquard_common::CowStr<'a>>,
135 ///The date and time of this write operation.
136 pub created_at: jacquard_common::types::string::Datetime,
137 ///The IP address used when initiating the AA flow.
138 #[serde(skip_serializing_if = "std::option::Option::is_none")]
139 #[serde(borrow)]
140 pub init_ip: std::option::Option<jacquard_common::CowStr<'a>>,
141 ///The user agent used when initiating the AA flow.
142 #[serde(skip_serializing_if = "std::option::Option::is_none")]
143 #[serde(borrow)]
144 pub init_ua: std::option::Option<jacquard_common::CowStr<'a>>,
145 ///The status of the age assurance process.
146 #[serde(borrow)]
147 pub status: jacquard_common::CowStr<'a>,
148}
149
150impl jacquard_common::IntoStatic for AgeAssuranceEvent<'_> {
151 type Output = AgeAssuranceEvent<'static>;
152 fn into_static(self) -> Self::Output {
153 AgeAssuranceEvent {
154 attempt_id: self.attempt_id.into_static(),
155 complete_ip: self.complete_ip.into_static(),
156 complete_ua: self.complete_ua.into_static(),
157 created_at: self.created_at.into_static(),
158 init_ip: self.init_ip.into_static(),
159 init_ua: self.init_ua.into_static(),
160 status: self.status.into_static(),
161 extra_data: self.extra_data.into_static(),
162 }
163 }
164}
165
166///Age assurance status override by moderators. Only works on DID subjects.
167#[jacquard_derive::lexicon]
168#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
169#[serde(rename_all = "camelCase")]
170pub struct AgeAssuranceOverrideEvent<'a> {
171 ///Comment describing the reason for the override.
172 #[serde(borrow)]
173 pub comment: jacquard_common::CowStr<'a>,
174 ///The status to be set for the user decided by a moderator, overriding whatever value the user had previously. Use reset to default to original state.
175 #[serde(borrow)]
176 pub status: jacquard_common::CowStr<'a>,
177}
178
179impl jacquard_common::IntoStatic for AgeAssuranceOverrideEvent<'_> {
180 type Output = AgeAssuranceOverrideEvent<'static>;
181 fn into_static(self) -> Self::Output {
182 AgeAssuranceOverrideEvent {
183 comment: self.comment.into_static(),
184 status: self.status.into_static(),
185 extra_data: self.extra_data.into_static(),
186 }
187 }
188}
189
190#[jacquard_derive::lexicon]
191#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
192#[serde(rename_all = "camelCase")]
193pub struct BlobView<'a> {
194 #[serde(borrow)]
195 pub cid: jacquard_common::types::string::Cid<'a>,
196 pub created_at: jacquard_common::types::string::Datetime,
197 #[serde(skip_serializing_if = "std::option::Option::is_none")]
198 #[serde(borrow)]
199 pub details: std::option::Option<BlobViewRecordDetails<'a>>,
200 #[serde(borrow)]
201 pub mime_type: jacquard_common::CowStr<'a>,
202 #[serde(skip_serializing_if = "std::option::Option::is_none")]
203 #[serde(borrow)]
204 pub moderation: std::option::Option<crate::tools_ozone::moderation::Moderation<'a>>,
205 pub size: i64,
206}
207
208#[jacquard_derive::open_union]
209#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
210#[serde(tag = "$type")]
211#[serde(bound(deserialize = "'de: 'a"))]
212pub enum BlobViewRecordDetails<'a> {}
213impl jacquard_common::IntoStatic for BlobViewRecordDetails<'_> {
214 type Output = BlobViewRecordDetails<'static>;
215 fn into_static(self) -> Self::Output {
216 match self {
217 BlobViewRecordDetails::Unknown(v) => {
218 BlobViewRecordDetails::Unknown(v.into_static())
219 }
220 }
221 }
222}
223
224impl jacquard_common::IntoStatic for BlobView<'_> {
225 type Output = BlobView<'static>;
226 fn into_static(self) -> Self::Output {
227 BlobView {
228 cid: self.cid.into_static(),
229 created_at: self.created_at.into_static(),
230 details: self.details.into_static(),
231 mime_type: self.mime_type.into_static(),
232 moderation: self.moderation.into_static(),
233 size: self.size.into_static(),
234 extra_data: self.extra_data.into_static(),
235 }
236 }
237}
238
239///Logs identity related events on a repo subject. Normally captured by automod from the firehose and emitted to ozone for historical tracking.
240#[jacquard_derive::lexicon]
241#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
242#[serde(rename_all = "camelCase")]
243pub struct IdentityEvent<'a> {
244 #[serde(skip_serializing_if = "std::option::Option::is_none")]
245 #[serde(borrow)]
246 pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
247 #[serde(skip_serializing_if = "std::option::Option::is_none")]
248 #[serde(borrow)]
249 pub handle: std::option::Option<jacquard_common::types::string::Handle<'a>>,
250 #[serde(skip_serializing_if = "std::option::Option::is_none")]
251 #[serde(borrow)]
252 pub pds_host: std::option::Option<jacquard_common::types::string::Uri<'a>>,
253 pub timestamp: jacquard_common::types::string::Datetime,
254 #[serde(skip_serializing_if = "std::option::Option::is_none")]
255 pub tombstone: std::option::Option<bool>,
256}
257
258impl jacquard_common::IntoStatic for IdentityEvent<'_> {
259 type Output = IdentityEvent<'static>;
260 fn into_static(self) -> Self::Output {
261 IdentityEvent {
262 comment: self.comment.into_static(),
263 handle: self.handle.into_static(),
264 pds_host: self.pds_host.into_static(),
265 timestamp: self.timestamp.into_static(),
266 tombstone: self.tombstone.into_static(),
267 extra_data: self.extra_data.into_static(),
268 }
269 }
270}
271
272#[jacquard_derive::lexicon]
273#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
274#[serde(rename_all = "camelCase")]
275pub struct ImageDetails<'a> {
276 pub height: i64,
277 pub width: i64,
278}
279
280impl jacquard_common::IntoStatic for ImageDetails<'_> {
281 type Output = ImageDetails<'static>;
282 fn into_static(self) -> Self::Output {
283 ImageDetails {
284 height: self.height.into_static(),
285 width: self.width.into_static(),
286 extra_data: self.extra_data.into_static(),
287 }
288 }
289}
290
291#[jacquard_derive::lexicon]
292#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
293#[serde(rename_all = "camelCase")]
294pub struct ModEventAcknowledge<'a> {
295 ///If true, all other reports on content authored by this account will be resolved (acknowledged).
296 #[serde(skip_serializing_if = "std::option::Option::is_none")]
297 pub acknowledge_account_subjects: std::option::Option<bool>,
298 #[serde(skip_serializing_if = "std::option::Option::is_none")]
299 #[serde(borrow)]
300 pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
301}
302
303impl jacquard_common::IntoStatic for ModEventAcknowledge<'_> {
304 type Output = ModEventAcknowledge<'static>;
305 fn into_static(self) -> Self::Output {
306 ModEventAcknowledge {
307 acknowledge_account_subjects: self
308 .acknowledge_account_subjects
309 .into_static(),
310 comment: self.comment.into_static(),
311 extra_data: self.extra_data.into_static(),
312 }
313 }
314}
315
316///Add a comment to a subject. An empty comment will clear any previously set sticky comment.
317#[jacquard_derive::lexicon]
318#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
319#[serde(rename_all = "camelCase")]
320pub struct ModEventComment<'a> {
321 #[serde(skip_serializing_if = "std::option::Option::is_none")]
322 #[serde(borrow)]
323 pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
324 ///Make the comment persistent on the subject
325 #[serde(skip_serializing_if = "std::option::Option::is_none")]
326 pub sticky: std::option::Option<bool>,
327}
328
329impl jacquard_common::IntoStatic for ModEventComment<'_> {
330 type Output = ModEventComment<'static>;
331 fn into_static(self) -> Self::Output {
332 ModEventComment {
333 comment: self.comment.into_static(),
334 sticky: self.sticky.into_static(),
335 extra_data: self.extra_data.into_static(),
336 }
337 }
338}
339
340///Divert a record's blobs to a 3rd party service for further scanning/tagging
341#[jacquard_derive::lexicon]
342#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
343#[serde(rename_all = "camelCase")]
344pub struct ModEventDivert<'a> {
345 #[serde(skip_serializing_if = "std::option::Option::is_none")]
346 #[serde(borrow)]
347 pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
348}
349
350impl jacquard_common::IntoStatic for ModEventDivert<'_> {
351 type Output = ModEventDivert<'static>;
352 fn into_static(self) -> Self::Output {
353 ModEventDivert {
354 comment: self.comment.into_static(),
355 extra_data: self.extra_data.into_static(),
356 }
357 }
358}
359
360///Keep a log of outgoing email to a user
361#[jacquard_derive::lexicon]
362#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
363#[serde(rename_all = "camelCase")]
364pub struct ModEventEmail<'a> {
365 ///Additional comment about the outgoing comm.
366 #[serde(skip_serializing_if = "std::option::Option::is_none")]
367 #[serde(borrow)]
368 pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
369 ///The content of the email sent to the user.
370 #[serde(skip_serializing_if = "std::option::Option::is_none")]
371 #[serde(borrow)]
372 pub content: std::option::Option<jacquard_common::CowStr<'a>>,
373 ///The subject line of the email sent to the user.
374 #[serde(borrow)]
375 pub subject_line: jacquard_common::CowStr<'a>,
376}
377
378impl jacquard_common::IntoStatic for ModEventEmail<'_> {
379 type Output = ModEventEmail<'static>;
380 fn into_static(self) -> Self::Output {
381 ModEventEmail {
382 comment: self.comment.into_static(),
383 content: self.content.into_static(),
384 subject_line: self.subject_line.into_static(),
385 extra_data: self.extra_data.into_static(),
386 }
387 }
388}
389
390#[jacquard_derive::lexicon]
391#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
392#[serde(rename_all = "camelCase")]
393pub struct ModEventEscalate<'a> {
394 #[serde(skip_serializing_if = "std::option::Option::is_none")]
395 #[serde(borrow)]
396 pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
397}
398
399impl jacquard_common::IntoStatic for ModEventEscalate<'_> {
400 type Output = ModEventEscalate<'static>;
401 fn into_static(self) -> Self::Output {
402 ModEventEscalate {
403 comment: self.comment.into_static(),
404 extra_data: self.extra_data.into_static(),
405 }
406 }
407}
408
409///Apply/Negate labels on a subject
410#[jacquard_derive::lexicon]
411#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
412#[serde(rename_all = "camelCase")]
413pub struct ModEventLabel<'a> {
414 #[serde(skip_serializing_if = "std::option::Option::is_none")]
415 #[serde(borrow)]
416 pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
417 #[serde(borrow)]
418 pub create_label_vals: Vec<jacquard_common::CowStr<'a>>,
419 ///Indicates how long the label will remain on the subject. Only applies on labels that are being added.
420 #[serde(skip_serializing_if = "std::option::Option::is_none")]
421 pub duration_in_hours: std::option::Option<i64>,
422 #[serde(borrow)]
423 pub negate_label_vals: Vec<jacquard_common::CowStr<'a>>,
424}
425
426impl jacquard_common::IntoStatic for ModEventLabel<'_> {
427 type Output = ModEventLabel<'static>;
428 fn into_static(self) -> Self::Output {
429 ModEventLabel {
430 comment: self.comment.into_static(),
431 create_label_vals: self.create_label_vals.into_static(),
432 duration_in_hours: self.duration_in_hours.into_static(),
433 negate_label_vals: self.negate_label_vals.into_static(),
434 extra_data: self.extra_data.into_static(),
435 }
436 }
437}
438
439///Mute incoming reports on a subject
440#[jacquard_derive::lexicon]
441#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
442#[serde(rename_all = "camelCase")]
443pub struct ModEventMute<'a> {
444 #[serde(skip_serializing_if = "std::option::Option::is_none")]
445 #[serde(borrow)]
446 pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
447 ///Indicates how long the subject should remain muted.
448 pub duration_in_hours: i64,
449}
450
451impl jacquard_common::IntoStatic for ModEventMute<'_> {
452 type Output = ModEventMute<'static>;
453 fn into_static(self) -> Self::Output {
454 ModEventMute {
455 comment: self.comment.into_static(),
456 duration_in_hours: self.duration_in_hours.into_static(),
457 extra_data: self.extra_data.into_static(),
458 }
459 }
460}
461
462///Mute incoming reports from an account
463#[jacquard_derive::lexicon]
464#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
465#[serde(rename_all = "camelCase")]
466pub struct ModEventMuteReporter<'a> {
467 #[serde(skip_serializing_if = "std::option::Option::is_none")]
468 #[serde(borrow)]
469 pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
470 ///Indicates how long the account should remain muted. Falsy value here means a permanent mute.
471 #[serde(skip_serializing_if = "std::option::Option::is_none")]
472 pub duration_in_hours: std::option::Option<i64>,
473}
474
475impl jacquard_common::IntoStatic for ModEventMuteReporter<'_> {
476 type Output = ModEventMuteReporter<'static>;
477 fn into_static(self) -> Self::Output {
478 ModEventMuteReporter {
479 comment: self.comment.into_static(),
480 duration_in_hours: self.duration_in_hours.into_static(),
481 extra_data: self.extra_data.into_static(),
482 }
483 }
484}
485
486///Set priority score of the subject. Higher score means higher priority.
487#[jacquard_derive::lexicon]
488#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
489#[serde(rename_all = "camelCase")]
490pub struct ModEventPriorityScore<'a> {
491 #[serde(skip_serializing_if = "std::option::Option::is_none")]
492 #[serde(borrow)]
493 pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
494 pub score: i64,
495}
496
497impl jacquard_common::IntoStatic for ModEventPriorityScore<'_> {
498 type Output = ModEventPriorityScore<'static>;
499 fn into_static(self) -> Self::Output {
500 ModEventPriorityScore {
501 comment: self.comment.into_static(),
502 score: self.score.into_static(),
503 extra_data: self.extra_data.into_static(),
504 }
505 }
506}
507
508///Report a subject
509#[jacquard_derive::lexicon]
510#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
511#[serde(rename_all = "camelCase")]
512pub struct ModEventReport<'a> {
513 #[serde(skip_serializing_if = "std::option::Option::is_none")]
514 #[serde(borrow)]
515 pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
516 ///Set to true if the reporter was muted from reporting at the time of the event. These reports won't impact the reviewState of the subject.
517 #[serde(skip_serializing_if = "std::option::Option::is_none")]
518 pub is_reporter_muted: std::option::Option<bool>,
519 #[serde(borrow)]
520 pub report_type: crate::com_atproto::moderation::ReasonType<'a>,
521}
522
523impl jacquard_common::IntoStatic for ModEventReport<'_> {
524 type Output = ModEventReport<'static>;
525 fn into_static(self) -> Self::Output {
526 ModEventReport {
527 comment: self.comment.into_static(),
528 is_reporter_muted: self.is_reporter_muted.into_static(),
529 report_type: self.report_type.into_static(),
530 extra_data: self.extra_data.into_static(),
531 }
532 }
533}
534
535///Resolve appeal on a subject
536#[jacquard_derive::lexicon]
537#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
538#[serde(rename_all = "camelCase")]
539pub struct ModEventResolveAppeal<'a> {
540 ///Describe resolution.
541 #[serde(skip_serializing_if = "std::option::Option::is_none")]
542 #[serde(borrow)]
543 pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
544}
545
546impl jacquard_common::IntoStatic for ModEventResolveAppeal<'_> {
547 type Output = ModEventResolveAppeal<'static>;
548 fn into_static(self) -> Self::Output {
549 ModEventResolveAppeal {
550 comment: self.comment.into_static(),
551 extra_data: self.extra_data.into_static(),
552 }
553 }
554}
555
556///Revert take down action on a subject
557#[jacquard_derive::lexicon]
558#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
559#[serde(rename_all = "camelCase")]
560pub struct ModEventReverseTakedown<'a> {
561 ///Describe reasoning behind the reversal.
562 #[serde(skip_serializing_if = "std::option::Option::is_none")]
563 #[serde(borrow)]
564 pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
565}
566
567impl jacquard_common::IntoStatic for ModEventReverseTakedown<'_> {
568 type Output = ModEventReverseTakedown<'static>;
569 fn into_static(self) -> Self::Output {
570 ModEventReverseTakedown {
571 comment: self.comment.into_static(),
572 extra_data: self.extra_data.into_static(),
573 }
574 }
575}
576
577///Add/Remove a tag on a subject
578#[jacquard_derive::lexicon]
579#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
580#[serde(rename_all = "camelCase")]
581pub struct ModEventTag<'a> {
582 ///Tags to be added to the subject. If already exists, won't be duplicated.
583 #[serde(borrow)]
584 pub add: Vec<jacquard_common::CowStr<'a>>,
585 ///Additional comment about added/removed tags.
586 #[serde(skip_serializing_if = "std::option::Option::is_none")]
587 #[serde(borrow)]
588 pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
589 ///Tags to be removed to the subject. Ignores a tag If it doesn't exist, won't be duplicated.
590 #[serde(borrow)]
591 pub remove: Vec<jacquard_common::CowStr<'a>>,
592}
593
594impl jacquard_common::IntoStatic for ModEventTag<'_> {
595 type Output = ModEventTag<'static>;
596 fn into_static(self) -> Self::Output {
597 ModEventTag {
598 add: self.add.into_static(),
599 comment: self.comment.into_static(),
600 remove: self.remove.into_static(),
601 extra_data: self.extra_data.into_static(),
602 }
603 }
604}
605
606///Take down a subject permanently or temporarily
607#[jacquard_derive::lexicon]
608#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
609#[serde(rename_all = "camelCase")]
610pub struct ModEventTakedown<'a> {
611 ///If true, all other reports on content authored by this account will be resolved (acknowledged).
612 #[serde(skip_serializing_if = "std::option::Option::is_none")]
613 pub acknowledge_account_subjects: std::option::Option<bool>,
614 #[serde(skip_serializing_if = "std::option::Option::is_none")]
615 #[serde(borrow)]
616 pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
617 ///Indicates how long the takedown should be in effect before automatically expiring.
618 #[serde(skip_serializing_if = "std::option::Option::is_none")]
619 pub duration_in_hours: std::option::Option<i64>,
620 ///Names/Keywords of the policies that drove the decision.
621 #[serde(skip_serializing_if = "std::option::Option::is_none")]
622 #[serde(borrow)]
623 pub policies: std::option::Option<Vec<jacquard_common::CowStr<'a>>>,
624}
625
626impl jacquard_common::IntoStatic for ModEventTakedown<'_> {
627 type Output = ModEventTakedown<'static>;
628 fn into_static(self) -> Self::Output {
629 ModEventTakedown {
630 acknowledge_account_subjects: self
631 .acknowledge_account_subjects
632 .into_static(),
633 comment: self.comment.into_static(),
634 duration_in_hours: self.duration_in_hours.into_static(),
635 policies: self.policies.into_static(),
636 extra_data: self.extra_data.into_static(),
637 }
638 }
639}
640
641///Unmute action on a subject
642#[jacquard_derive::lexicon]
643#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
644#[serde(rename_all = "camelCase")]
645pub struct ModEventUnmute<'a> {
646 ///Describe reasoning behind the reversal.
647 #[serde(skip_serializing_if = "std::option::Option::is_none")]
648 #[serde(borrow)]
649 pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
650}
651
652impl jacquard_common::IntoStatic for ModEventUnmute<'_> {
653 type Output = ModEventUnmute<'static>;
654 fn into_static(self) -> Self::Output {
655 ModEventUnmute {
656 comment: self.comment.into_static(),
657 extra_data: self.extra_data.into_static(),
658 }
659 }
660}
661
662///Unmute incoming reports from an account
663#[jacquard_derive::lexicon]
664#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
665#[serde(rename_all = "camelCase")]
666pub struct ModEventUnmuteReporter<'a> {
667 ///Describe reasoning behind the reversal.
668 #[serde(skip_serializing_if = "std::option::Option::is_none")]
669 #[serde(borrow)]
670 pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
671}
672
673impl jacquard_common::IntoStatic for ModEventUnmuteReporter<'_> {
674 type Output = ModEventUnmuteReporter<'static>;
675 fn into_static(self) -> Self::Output {
676 ModEventUnmuteReporter {
677 comment: self.comment.into_static(),
678 extra_data: self.extra_data.into_static(),
679 }
680 }
681}
682
683#[jacquard_derive::lexicon]
684#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
685#[serde(rename_all = "camelCase")]
686pub struct ModEventView<'a> {
687 pub created_at: jacquard_common::types::string::Datetime,
688 #[serde(borrow)]
689 pub created_by: jacquard_common::types::string::Did<'a>,
690 #[serde(skip_serializing_if = "std::option::Option::is_none")]
691 #[serde(borrow)]
692 pub creator_handle: std::option::Option<jacquard_common::CowStr<'a>>,
693 #[serde(borrow)]
694 pub event: ModEventViewRecordEvent<'a>,
695 pub id: i64,
696 #[serde(skip_serializing_if = "std::option::Option::is_none")]
697 #[serde(borrow)]
698 pub mod_tool: std::option::Option<crate::tools_ozone::moderation::ModTool<'a>>,
699 #[serde(borrow)]
700 pub subject: ModEventViewRecordSubject<'a>,
701 #[serde(borrow)]
702 pub subject_blob_cids: Vec<jacquard_common::CowStr<'a>>,
703 #[serde(skip_serializing_if = "std::option::Option::is_none")]
704 #[serde(borrow)]
705 pub subject_handle: std::option::Option<jacquard_common::CowStr<'a>>,
706}
707
708#[jacquard_derive::open_union]
709#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
710#[serde(tag = "$type")]
711#[serde(bound(deserialize = "'de: 'a"))]
712pub enum ModEventViewRecordEvent<'a> {}
713impl jacquard_common::IntoStatic for ModEventViewRecordEvent<'_> {
714 type Output = ModEventViewRecordEvent<'static>;
715 fn into_static(self) -> Self::Output {
716 match self {
717 ModEventViewRecordEvent::Unknown(v) => {
718 ModEventViewRecordEvent::Unknown(v.into_static())
719 }
720 }
721 }
722}
723
724#[jacquard_derive::open_union]
725#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
726#[serde(tag = "$type")]
727#[serde(bound(deserialize = "'de: 'a"))]
728pub enum ModEventViewRecordSubject<'a> {
729 #[serde(rename = "com.atproto.admin.defs#repoRef")]
730 DefsRepoRef(Box<crate::com_atproto::admin::RepoRef<'a>>),
731 #[serde(rename = "com.atproto.repo.strongRef")]
732 StrongRef(Box<crate::com_atproto::repo::strong_ref::StrongRef<'a>>),
733 #[serde(rename = "chat.bsky.convo.defs#messageRef")]
734 DefsMessageRef(Box<crate::chat_bsky::convo::MessageRef<'a>>),
735}
736
737impl jacquard_common::IntoStatic for ModEventViewRecordSubject<'_> {
738 type Output = ModEventViewRecordSubject<'static>;
739 fn into_static(self) -> Self::Output {
740 match self {
741 ModEventViewRecordSubject::DefsRepoRef(v) => {
742 ModEventViewRecordSubject::DefsRepoRef(v.into_static())
743 }
744 ModEventViewRecordSubject::StrongRef(v) => {
745 ModEventViewRecordSubject::StrongRef(v.into_static())
746 }
747 ModEventViewRecordSubject::DefsMessageRef(v) => {
748 ModEventViewRecordSubject::DefsMessageRef(v.into_static())
749 }
750 ModEventViewRecordSubject::Unknown(v) => {
751 ModEventViewRecordSubject::Unknown(v.into_static())
752 }
753 }
754 }
755}
756
757impl jacquard_common::IntoStatic for ModEventView<'_> {
758 type Output = ModEventView<'static>;
759 fn into_static(self) -> Self::Output {
760 ModEventView {
761 created_at: self.created_at.into_static(),
762 created_by: self.created_by.into_static(),
763 creator_handle: self.creator_handle.into_static(),
764 event: self.event.into_static(),
765 id: self.id.into_static(),
766 mod_tool: self.mod_tool.into_static(),
767 subject: self.subject.into_static(),
768 subject_blob_cids: self.subject_blob_cids.into_static(),
769 subject_handle: self.subject_handle.into_static(),
770 extra_data: self.extra_data.into_static(),
771 }
772 }
773}
774
775#[jacquard_derive::lexicon]
776#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
777#[serde(rename_all = "camelCase")]
778pub struct ModEventViewDetail<'a> {
779 pub created_at: jacquard_common::types::string::Datetime,
780 #[serde(borrow)]
781 pub created_by: jacquard_common::types::string::Did<'a>,
782 #[serde(borrow)]
783 pub event: ModEventViewDetailRecordEvent<'a>,
784 pub id: i64,
785 #[serde(skip_serializing_if = "std::option::Option::is_none")]
786 #[serde(borrow)]
787 pub mod_tool: std::option::Option<crate::tools_ozone::moderation::ModTool<'a>>,
788 #[serde(borrow)]
789 pub subject: ModEventViewDetailRecordSubject<'a>,
790 #[serde(borrow)]
791 pub subject_blobs: Vec<crate::tools_ozone::moderation::BlobView<'a>>,
792}
793
794#[jacquard_derive::open_union]
795#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
796#[serde(tag = "$type")]
797#[serde(bound(deserialize = "'de: 'a"))]
798pub enum ModEventViewDetailRecordEvent<'a> {}
799impl jacquard_common::IntoStatic for ModEventViewDetailRecordEvent<'_> {
800 type Output = ModEventViewDetailRecordEvent<'static>;
801 fn into_static(self) -> Self::Output {
802 match self {
803 ModEventViewDetailRecordEvent::Unknown(v) => {
804 ModEventViewDetailRecordEvent::Unknown(v.into_static())
805 }
806 }
807 }
808}
809
810#[jacquard_derive::open_union]
811#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
812#[serde(tag = "$type")]
813#[serde(bound(deserialize = "'de: 'a"))]
814pub enum ModEventViewDetailRecordSubject<'a> {}
815impl jacquard_common::IntoStatic for ModEventViewDetailRecordSubject<'_> {
816 type Output = ModEventViewDetailRecordSubject<'static>;
817 fn into_static(self) -> Self::Output {
818 match self {
819 ModEventViewDetailRecordSubject::Unknown(v) => {
820 ModEventViewDetailRecordSubject::Unknown(v.into_static())
821 }
822 }
823 }
824}
825
826impl jacquard_common::IntoStatic for ModEventViewDetail<'_> {
827 type Output = ModEventViewDetail<'static>;
828 fn into_static(self) -> Self::Output {
829 ModEventViewDetail {
830 created_at: self.created_at.into_static(),
831 created_by: self.created_by.into_static(),
832 event: self.event.into_static(),
833 id: self.id.into_static(),
834 mod_tool: self.mod_tool.into_static(),
835 subject: self.subject.into_static(),
836 subject_blobs: self.subject_blobs.into_static(),
837 extra_data: self.extra_data.into_static(),
838 }
839 }
840}
841
842///Moderation tool information for tracing the source of the action
843#[jacquard_derive::lexicon]
844#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
845#[serde(rename_all = "camelCase")]
846pub struct ModTool<'a> {
847 ///Additional arbitrary metadata about the source
848 #[serde(skip_serializing_if = "std::option::Option::is_none")]
849 #[serde(borrow)]
850 pub meta: std::option::Option<jacquard_common::types::value::Data<'a>>,
851 ///Name/identifier of the source (e.g., 'automod', 'ozone/workspace')
852 #[serde(borrow)]
853 pub name: jacquard_common::CowStr<'a>,
854}
855
856impl jacquard_common::IntoStatic for ModTool<'_> {
857 type Output = ModTool<'static>;
858 fn into_static(self) -> Self::Output {
859 ModTool {
860 meta: self.meta.into_static(),
861 name: self.name.into_static(),
862 extra_data: self.extra_data.into_static(),
863 }
864 }
865}
866
867#[jacquard_derive::lexicon]
868#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
869#[serde(rename_all = "camelCase")]
870pub struct Moderation<'a> {
871 #[serde(skip_serializing_if = "std::option::Option::is_none")]
872 #[serde(borrow)]
873 pub subject_status: std::option::Option<
874 crate::tools_ozone::moderation::SubjectStatusView<'a>,
875 >,
876}
877
878impl jacquard_common::IntoStatic for Moderation<'_> {
879 type Output = Moderation<'static>;
880 fn into_static(self) -> Self::Output {
881 Moderation {
882 subject_status: self.subject_status.into_static(),
883 extra_data: self.extra_data.into_static(),
884 }
885 }
886}
887
888#[jacquard_derive::lexicon]
889#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
890#[serde(rename_all = "camelCase")]
891pub struct ModerationDetail<'a> {
892 #[serde(skip_serializing_if = "std::option::Option::is_none")]
893 #[serde(borrow)]
894 pub subject_status: std::option::Option<
895 crate::tools_ozone::moderation::SubjectStatusView<'a>,
896 >,
897}
898
899impl jacquard_common::IntoStatic for ModerationDetail<'_> {
900 type Output = ModerationDetail<'static>;
901 fn into_static(self) -> Self::Output {
902 ModerationDetail {
903 subject_status: self.subject_status.into_static(),
904 extra_data: self.extra_data.into_static(),
905 }
906 }
907}
908
909///Logs lifecycle event on a record subject. Normally captured by automod from the firehose and emitted to ozone for historical tracking.
910#[jacquard_derive::lexicon]
911#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
912#[serde(rename_all = "camelCase")]
913pub struct RecordEvent<'a> {
914 #[serde(skip_serializing_if = "std::option::Option::is_none")]
915 #[serde(borrow)]
916 pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>,
917 #[serde(skip_serializing_if = "std::option::Option::is_none")]
918 #[serde(borrow)]
919 pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
920 #[serde(borrow)]
921 pub op: jacquard_common::CowStr<'a>,
922 pub timestamp: jacquard_common::types::string::Datetime,
923}
924
925impl jacquard_common::IntoStatic for RecordEvent<'_> {
926 type Output = RecordEvent<'static>;
927 fn into_static(self) -> Self::Output {
928 RecordEvent {
929 cid: self.cid.into_static(),
930 comment: self.comment.into_static(),
931 op: self.op.into_static(),
932 timestamp: self.timestamp.into_static(),
933 extra_data: self.extra_data.into_static(),
934 }
935 }
936}
937
938#[jacquard_derive::lexicon]
939#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
940#[serde(rename_all = "camelCase")]
941pub struct RecordHosting<'a> {
942 #[serde(skip_serializing_if = "std::option::Option::is_none")]
943 pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,
944 #[serde(skip_serializing_if = "std::option::Option::is_none")]
945 pub deleted_at: std::option::Option<jacquard_common::types::string::Datetime>,
946 #[serde(borrow)]
947 pub status: jacquard_common::CowStr<'a>,
948 #[serde(skip_serializing_if = "std::option::Option::is_none")]
949 pub updated_at: std::option::Option<jacquard_common::types::string::Datetime>,
950}
951
952impl jacquard_common::IntoStatic for RecordHosting<'_> {
953 type Output = RecordHosting<'static>;
954 fn into_static(self) -> Self::Output {
955 RecordHosting {
956 created_at: self.created_at.into_static(),
957 deleted_at: self.deleted_at.into_static(),
958 status: self.status.into_static(),
959 updated_at: self.updated_at.into_static(),
960 extra_data: self.extra_data.into_static(),
961 }
962 }
963}
964
965#[jacquard_derive::lexicon]
966#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
967#[serde(rename_all = "camelCase")]
968pub struct RecordView<'a> {
969 #[serde(borrow)]
970 pub blob_cids: Vec<jacquard_common::types::string::Cid<'a>>,
971 #[serde(borrow)]
972 pub cid: jacquard_common::types::string::Cid<'a>,
973 pub indexed_at: jacquard_common::types::string::Datetime,
974 #[serde(borrow)]
975 pub moderation: crate::tools_ozone::moderation::Moderation<'a>,
976 #[serde(borrow)]
977 pub repo: crate::tools_ozone::moderation::RepoView<'a>,
978 #[serde(borrow)]
979 pub uri: jacquard_common::types::string::AtUri<'a>,
980 #[serde(borrow)]
981 pub value: jacquard_common::types::value::Data<'a>,
982}
983
984impl jacquard_common::IntoStatic for RecordView<'_> {
985 type Output = RecordView<'static>;
986 fn into_static(self) -> Self::Output {
987 RecordView {
988 blob_cids: self.blob_cids.into_static(),
989 cid: self.cid.into_static(),
990 indexed_at: self.indexed_at.into_static(),
991 moderation: self.moderation.into_static(),
992 repo: self.repo.into_static(),
993 uri: self.uri.into_static(),
994 value: self.value.into_static(),
995 extra_data: self.extra_data.into_static(),
996 }
997 }
998}
999
1000#[jacquard_derive::lexicon]
1001#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
1002#[serde(rename_all = "camelCase")]
1003pub struct RecordViewDetail<'a> {
1004 #[serde(borrow)]
1005 pub blobs: Vec<crate::tools_ozone::moderation::BlobView<'a>>,
1006 #[serde(borrow)]
1007 pub cid: jacquard_common::types::string::Cid<'a>,
1008 pub indexed_at: jacquard_common::types::string::Datetime,
1009 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1010 #[serde(borrow)]
1011 pub labels: std::option::Option<Vec<crate::com_atproto::label::Label<'a>>>,
1012 #[serde(borrow)]
1013 pub moderation: crate::tools_ozone::moderation::ModerationDetail<'a>,
1014 #[serde(borrow)]
1015 pub repo: crate::tools_ozone::moderation::RepoView<'a>,
1016 #[serde(borrow)]
1017 pub uri: jacquard_common::types::string::AtUri<'a>,
1018 #[serde(borrow)]
1019 pub value: jacquard_common::types::value::Data<'a>,
1020}
1021
1022impl jacquard_common::IntoStatic for RecordViewDetail<'_> {
1023 type Output = RecordViewDetail<'static>;
1024 fn into_static(self) -> Self::Output {
1025 RecordViewDetail {
1026 blobs: self.blobs.into_static(),
1027 cid: self.cid.into_static(),
1028 indexed_at: self.indexed_at.into_static(),
1029 labels: self.labels.into_static(),
1030 moderation: self.moderation.into_static(),
1031 repo: self.repo.into_static(),
1032 uri: self.uri.into_static(),
1033 value: self.value.into_static(),
1034 extra_data: self.extra_data.into_static(),
1035 }
1036 }
1037}
1038
1039#[jacquard_derive::lexicon]
1040#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
1041#[serde(rename_all = "camelCase")]
1042pub struct RecordViewNotFound<'a> {
1043 #[serde(borrow)]
1044 pub uri: jacquard_common::types::string::AtUri<'a>,
1045}
1046
1047impl jacquard_common::IntoStatic for RecordViewNotFound<'_> {
1048 type Output = RecordViewNotFound<'static>;
1049 fn into_static(self) -> Self::Output {
1050 RecordViewNotFound {
1051 uri: self.uri.into_static(),
1052 extra_data: self.extra_data.into_static(),
1053 }
1054 }
1055}
1056
1057///Statistics about a set of record subject items
1058#[jacquard_derive::lexicon]
1059#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
1060#[serde(rename_all = "camelCase")]
1061pub struct RecordsStats<'a> {
1062 ///Number of items that were appealed at least once
1063 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1064 pub appealed_count: std::option::Option<i64>,
1065 ///Number of items that were escalated at least once
1066 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1067 pub escalated_count: std::option::Option<i64>,
1068 ///Number of item currently in "reviewOpen" or "reviewEscalated" state
1069 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1070 pub pending_count: std::option::Option<i64>,
1071 ///Number of item currently in "reviewNone" or "reviewClosed" state
1072 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1073 pub processed_count: std::option::Option<i64>,
1074 ///Number of items that were reported at least once
1075 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1076 pub reported_count: std::option::Option<i64>,
1077 ///Total number of item in the set
1078 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1079 pub subject_count: std::option::Option<i64>,
1080 ///Number of item currently taken down
1081 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1082 pub takendown_count: std::option::Option<i64>,
1083 ///Cumulative sum of the number of reports on the items in the set
1084 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1085 pub total_reports: std::option::Option<i64>,
1086}
1087
1088impl jacquard_common::IntoStatic for RecordsStats<'_> {
1089 type Output = RecordsStats<'static>;
1090 fn into_static(self) -> Self::Output {
1091 RecordsStats {
1092 appealed_count: self.appealed_count.into_static(),
1093 escalated_count: self.escalated_count.into_static(),
1094 pending_count: self.pending_count.into_static(),
1095 processed_count: self.processed_count.into_static(),
1096 reported_count: self.reported_count.into_static(),
1097 subject_count: self.subject_count.into_static(),
1098 takendown_count: self.takendown_count.into_static(),
1099 total_reports: self.total_reports.into_static(),
1100 extra_data: self.extra_data.into_static(),
1101 }
1102 }
1103}
1104
1105#[jacquard_derive::lexicon]
1106#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
1107#[serde(rename_all = "camelCase")]
1108pub struct RepoView<'a> {
1109 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1110 pub deactivated_at: std::option::Option<jacquard_common::types::string::Datetime>,
1111 #[serde(borrow)]
1112 pub did: jacquard_common::types::string::Did<'a>,
1113 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1114 #[serde(borrow)]
1115 pub email: std::option::Option<jacquard_common::CowStr<'a>>,
1116 #[serde(borrow)]
1117 pub handle: jacquard_common::types::string::Handle<'a>,
1118 pub indexed_at: jacquard_common::types::string::Datetime,
1119 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1120 #[serde(borrow)]
1121 pub invite_note: std::option::Option<jacquard_common::CowStr<'a>>,
1122 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1123 #[serde(borrow)]
1124 pub invited_by: std::option::Option<crate::com_atproto::server::InviteCode<'a>>,
1125 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1126 pub invites_disabled: std::option::Option<bool>,
1127 #[serde(borrow)]
1128 pub moderation: crate::tools_ozone::moderation::Moderation<'a>,
1129 #[serde(borrow)]
1130 pub related_records: Vec<jacquard_common::types::value::Data<'a>>,
1131 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1132 #[serde(borrow)]
1133 pub threat_signatures: std::option::Option<
1134 Vec<crate::com_atproto::admin::ThreatSignature<'a>>,
1135 >,
1136}
1137
1138impl jacquard_common::IntoStatic for RepoView<'_> {
1139 type Output = RepoView<'static>;
1140 fn into_static(self) -> Self::Output {
1141 RepoView {
1142 deactivated_at: self.deactivated_at.into_static(),
1143 did: self.did.into_static(),
1144 email: self.email.into_static(),
1145 handle: self.handle.into_static(),
1146 indexed_at: self.indexed_at.into_static(),
1147 invite_note: self.invite_note.into_static(),
1148 invited_by: self.invited_by.into_static(),
1149 invites_disabled: self.invites_disabled.into_static(),
1150 moderation: self.moderation.into_static(),
1151 related_records: self.related_records.into_static(),
1152 threat_signatures: self.threat_signatures.into_static(),
1153 extra_data: self.extra_data.into_static(),
1154 }
1155 }
1156}
1157
1158#[jacquard_derive::lexicon]
1159#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
1160#[serde(rename_all = "camelCase")]
1161pub struct RepoViewDetail<'a> {
1162 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1163 pub deactivated_at: std::option::Option<jacquard_common::types::string::Datetime>,
1164 #[serde(borrow)]
1165 pub did: jacquard_common::types::string::Did<'a>,
1166 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1167 #[serde(borrow)]
1168 pub email: std::option::Option<jacquard_common::CowStr<'a>>,
1169 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1170 pub email_confirmed_at: std::option::Option<
1171 jacquard_common::types::string::Datetime,
1172 >,
1173 #[serde(borrow)]
1174 pub handle: jacquard_common::types::string::Handle<'a>,
1175 pub indexed_at: jacquard_common::types::string::Datetime,
1176 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1177 #[serde(borrow)]
1178 pub invite_note: std::option::Option<jacquard_common::CowStr<'a>>,
1179 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1180 #[serde(borrow)]
1181 pub invited_by: std::option::Option<crate::com_atproto::server::InviteCode<'a>>,
1182 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1183 #[serde(borrow)]
1184 pub invites: std::option::Option<Vec<crate::com_atproto::server::InviteCode<'a>>>,
1185 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1186 pub invites_disabled: std::option::Option<bool>,
1187 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1188 #[serde(borrow)]
1189 pub labels: std::option::Option<Vec<crate::com_atproto::label::Label<'a>>>,
1190 #[serde(borrow)]
1191 pub moderation: crate::tools_ozone::moderation::ModerationDetail<'a>,
1192 #[serde(borrow)]
1193 pub related_records: Vec<jacquard_common::types::value::Data<'a>>,
1194 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1195 #[serde(borrow)]
1196 pub threat_signatures: std::option::Option<
1197 Vec<crate::com_atproto::admin::ThreatSignature<'a>>,
1198 >,
1199}
1200
1201impl jacquard_common::IntoStatic for RepoViewDetail<'_> {
1202 type Output = RepoViewDetail<'static>;
1203 fn into_static(self) -> Self::Output {
1204 RepoViewDetail {
1205 deactivated_at: self.deactivated_at.into_static(),
1206 did: self.did.into_static(),
1207 email: self.email.into_static(),
1208 email_confirmed_at: self.email_confirmed_at.into_static(),
1209 handle: self.handle.into_static(),
1210 indexed_at: self.indexed_at.into_static(),
1211 invite_note: self.invite_note.into_static(),
1212 invited_by: self.invited_by.into_static(),
1213 invites: self.invites.into_static(),
1214 invites_disabled: self.invites_disabled.into_static(),
1215 labels: self.labels.into_static(),
1216 moderation: self.moderation.into_static(),
1217 related_records: self.related_records.into_static(),
1218 threat_signatures: self.threat_signatures.into_static(),
1219 extra_data: self.extra_data.into_static(),
1220 }
1221 }
1222}
1223
1224#[jacquard_derive::lexicon]
1225#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
1226#[serde(rename_all = "camelCase")]
1227pub struct RepoViewNotFound<'a> {
1228 #[serde(borrow)]
1229 pub did: jacquard_common::types::string::Did<'a>,
1230}
1231
1232impl jacquard_common::IntoStatic for RepoViewNotFound<'_> {
1233 type Output = RepoViewNotFound<'static>;
1234 fn into_static(self) -> Self::Output {
1235 RepoViewNotFound {
1236 did: self.did.into_static(),
1237 extra_data: self.extra_data.into_static(),
1238 }
1239 }
1240}
1241
1242#[jacquard_derive::lexicon]
1243#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
1244#[serde(rename_all = "camelCase")]
1245pub struct ReporterStats<'a> {
1246 ///The total number of reports made by the user on accounts.
1247 pub account_report_count: i64,
1248 #[serde(borrow)]
1249 pub did: jacquard_common::types::string::Did<'a>,
1250 ///The total number of accounts labeled as a result of the user's reports.
1251 pub labeled_account_count: i64,
1252 ///The total number of records labeled as a result of the user's reports.
1253 pub labeled_record_count: i64,
1254 ///The total number of reports made by the user on records.
1255 pub record_report_count: i64,
1256 ///The total number of accounts reported by the user.
1257 pub reported_account_count: i64,
1258 ///The total number of records reported by the user.
1259 pub reported_record_count: i64,
1260 ///The total number of accounts taken down as a result of the user's reports.
1261 pub takendown_account_count: i64,
1262 ///The total number of records taken down as a result of the user's reports.
1263 pub takendown_record_count: i64,
1264}
1265
1266impl jacquard_common::IntoStatic for ReporterStats<'_> {
1267 type Output = ReporterStats<'static>;
1268 fn into_static(self) -> Self::Output {
1269 ReporterStats {
1270 account_report_count: self.account_report_count.into_static(),
1271 did: self.did.into_static(),
1272 labeled_account_count: self.labeled_account_count.into_static(),
1273 labeled_record_count: self.labeled_record_count.into_static(),
1274 record_report_count: self.record_report_count.into_static(),
1275 reported_account_count: self.reported_account_count.into_static(),
1276 reported_record_count: self.reported_record_count.into_static(),
1277 takendown_account_count: self.takendown_account_count.into_static(),
1278 takendown_record_count: self.takendown_record_count.into_static(),
1279 extra_data: self.extra_data.into_static(),
1280 }
1281 }
1282}
1283
1284///Account credentials revocation by moderators. Only works on DID subjects.
1285#[jacquard_derive::lexicon]
1286#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
1287#[serde(rename_all = "camelCase")]
1288pub struct RevokeAccountCredentialsEvent<'a> {
1289 ///Comment describing the reason for the revocation.
1290 #[serde(borrow)]
1291 pub comment: jacquard_common::CowStr<'a>,
1292}
1293
1294impl jacquard_common::IntoStatic for RevokeAccountCredentialsEvent<'_> {
1295 type Output = RevokeAccountCredentialsEvent<'static>;
1296 fn into_static(self) -> Self::Output {
1297 RevokeAccountCredentialsEvent {
1298 comment: self.comment.into_static(),
1299 extra_data: self.extra_data.into_static(),
1300 }
1301 }
1302}
1303
1304#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1305pub enum SubjectReviewState<'a> {
1306 ReviewOpen,
1307 ReviewEscalated,
1308 ReviewClosed,
1309 ReviewNone,
1310 Other(jacquard_common::CowStr<'a>),
1311}
1312
1313impl<'a> SubjectReviewState<'a> {
1314 pub fn as_str(&self) -> &str {
1315 match self {
1316 Self::ReviewOpen => "#reviewOpen",
1317 Self::ReviewEscalated => "#reviewEscalated",
1318 Self::ReviewClosed => "#reviewClosed",
1319 Self::ReviewNone => "#reviewNone",
1320 Self::Other(s) => s.as_ref(),
1321 }
1322 }
1323}
1324
1325impl<'a> From<&'a str> for SubjectReviewState<'a> {
1326 fn from(s: &'a str) -> Self {
1327 match s {
1328 "#reviewOpen" => Self::ReviewOpen,
1329 "#reviewEscalated" => Self::ReviewEscalated,
1330 "#reviewClosed" => Self::ReviewClosed,
1331 "#reviewNone" => Self::ReviewNone,
1332 _ => Self::Other(jacquard_common::CowStr::from(s)),
1333 }
1334 }
1335}
1336
1337impl<'a> From<String> for SubjectReviewState<'a> {
1338 fn from(s: String) -> Self {
1339 match s.as_str() {
1340 "#reviewOpen" => Self::ReviewOpen,
1341 "#reviewEscalated" => Self::ReviewEscalated,
1342 "#reviewClosed" => Self::ReviewClosed,
1343 "#reviewNone" => Self::ReviewNone,
1344 _ => Self::Other(jacquard_common::CowStr::from(s)),
1345 }
1346 }
1347}
1348
1349impl<'a> AsRef<str> for SubjectReviewState<'a> {
1350 fn as_ref(&self) -> &str {
1351 self.as_str()
1352 }
1353}
1354
1355impl<'a> serde::Serialize for SubjectReviewState<'a> {
1356 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1357 where
1358 S: serde::Serializer,
1359 {
1360 serializer.serialize_str(self.as_str())
1361 }
1362}
1363
1364impl<'de, 'a> serde::Deserialize<'de> for SubjectReviewState<'a>
1365where
1366 'de: 'a,
1367{
1368 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1369 where
1370 D: serde::Deserializer<'de>,
1371 {
1372 let s = <&'de str>::deserialize(deserializer)?;
1373 Ok(Self::from(s))
1374 }
1375}
1376
1377impl jacquard_common::IntoStatic for SubjectReviewState<'_> {
1378 type Output = SubjectReviewState<'static>;
1379 fn into_static(self) -> Self::Output {
1380 match self {
1381 SubjectReviewState::ReviewOpen => SubjectReviewState::ReviewOpen,
1382 SubjectReviewState::ReviewEscalated => SubjectReviewState::ReviewEscalated,
1383 SubjectReviewState::ReviewClosed => SubjectReviewState::ReviewClosed,
1384 SubjectReviewState::ReviewNone => SubjectReviewState::ReviewNone,
1385 SubjectReviewState::Other(v) => SubjectReviewState::Other(v.into_static()),
1386 }
1387 }
1388}
1389
1390#[jacquard_derive::lexicon]
1391#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
1392#[serde(rename_all = "camelCase")]
1393pub struct SubjectStatusView<'a> {
1394 ///Statistics related to the account subject
1395 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1396 #[serde(borrow)]
1397 pub account_stats: std::option::Option<
1398 crate::tools_ozone::moderation::AccountStats<'a>,
1399 >,
1400 ///Current age assurance state of the subject.
1401 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1402 #[serde(borrow)]
1403 pub age_assurance_state: std::option::Option<jacquard_common::CowStr<'a>>,
1404 ///Whether or not the last successful update to age assurance was made by the user or admin.
1405 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1406 #[serde(borrow)]
1407 pub age_assurance_updated_by: std::option::Option<jacquard_common::CowStr<'a>>,
1408 ///True indicates that the a previously taken moderator action was appealed against, by the author of the content. False indicates last appeal was resolved by moderators.
1409 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1410 pub appealed: std::option::Option<bool>,
1411 ///Sticky comment on the subject.
1412 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1413 #[serde(borrow)]
1414 pub comment: std::option::Option<jacquard_common::CowStr<'a>>,
1415 ///Timestamp referencing the first moderation status impacting event was emitted on the subject
1416 pub created_at: jacquard_common::types::string::Datetime,
1417 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1418 #[serde(borrow)]
1419 pub hosting: std::option::Option<SubjectStatusViewRecordHosting<'a>>,
1420 pub id: i64,
1421 ///Timestamp referencing when the author of the subject appealed a moderation action
1422 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1423 pub last_appealed_at: std::option::Option<jacquard_common::types::string::Datetime>,
1424 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1425 pub last_reported_at: std::option::Option<jacquard_common::types::string::Datetime>,
1426 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1427 pub last_reviewed_at: std::option::Option<jacquard_common::types::string::Datetime>,
1428 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1429 #[serde(borrow)]
1430 pub last_reviewed_by: std::option::Option<jacquard_common::types::string::Did<'a>>,
1431 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1432 pub mute_reporting_until: std::option::Option<
1433 jacquard_common::types::string::Datetime,
1434 >,
1435 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1436 pub mute_until: std::option::Option<jacquard_common::types::string::Datetime>,
1437 ///Numeric value representing the level of priority. Higher score means higher priority.
1438 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1439 pub priority_score: std::option::Option<i64>,
1440 ///Statistics related to the record subjects authored by the subject's account
1441 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1442 #[serde(borrow)]
1443 pub records_stats: std::option::Option<
1444 crate::tools_ozone::moderation::RecordsStats<'a>,
1445 >,
1446 #[serde(borrow)]
1447 pub review_state: crate::tools_ozone::moderation::SubjectReviewState<'a>,
1448 #[serde(borrow)]
1449 pub subject: SubjectStatusViewRecordSubject<'a>,
1450 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1451 #[serde(borrow)]
1452 pub subject_blob_cids: std::option::Option<
1453 Vec<jacquard_common::types::string::Cid<'a>>,
1454 >,
1455 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1456 #[serde(borrow)]
1457 pub subject_repo_handle: std::option::Option<jacquard_common::CowStr<'a>>,
1458 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1459 pub suspend_until: std::option::Option<jacquard_common::types::string::Datetime>,
1460 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1461 #[serde(borrow)]
1462 pub tags: std::option::Option<Vec<jacquard_common::CowStr<'a>>>,
1463 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1464 pub takendown: std::option::Option<bool>,
1465 ///Timestamp referencing when the last update was made to the moderation status of the subject
1466 pub updated_at: jacquard_common::types::string::Datetime,
1467}
1468
1469#[jacquard_derive::open_union]
1470#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
1471#[serde(tag = "$type")]
1472#[serde(bound(deserialize = "'de: 'a"))]
1473pub enum SubjectStatusViewRecordHosting<'a> {}
1474impl jacquard_common::IntoStatic for SubjectStatusViewRecordHosting<'_> {
1475 type Output = SubjectStatusViewRecordHosting<'static>;
1476 fn into_static(self) -> Self::Output {
1477 match self {
1478 SubjectStatusViewRecordHosting::Unknown(v) => {
1479 SubjectStatusViewRecordHosting::Unknown(v.into_static())
1480 }
1481 }
1482 }
1483}
1484
1485#[jacquard_derive::open_union]
1486#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
1487#[serde(tag = "$type")]
1488#[serde(bound(deserialize = "'de: 'a"))]
1489pub enum SubjectStatusViewRecordSubject<'a> {
1490 #[serde(rename = "com.atproto.admin.defs#repoRef")]
1491 DefsRepoRef(Box<crate::com_atproto::admin::RepoRef<'a>>),
1492 #[serde(rename = "com.atproto.repo.strongRef")]
1493 StrongRef(Box<crate::com_atproto::repo::strong_ref::StrongRef<'a>>),
1494 #[serde(rename = "chat.bsky.convo.defs#messageRef")]
1495 DefsMessageRef(Box<crate::chat_bsky::convo::MessageRef<'a>>),
1496}
1497
1498impl jacquard_common::IntoStatic for SubjectStatusViewRecordSubject<'_> {
1499 type Output = SubjectStatusViewRecordSubject<'static>;
1500 fn into_static(self) -> Self::Output {
1501 match self {
1502 SubjectStatusViewRecordSubject::DefsRepoRef(v) => {
1503 SubjectStatusViewRecordSubject::DefsRepoRef(v.into_static())
1504 }
1505 SubjectStatusViewRecordSubject::StrongRef(v) => {
1506 SubjectStatusViewRecordSubject::StrongRef(v.into_static())
1507 }
1508 SubjectStatusViewRecordSubject::DefsMessageRef(v) => {
1509 SubjectStatusViewRecordSubject::DefsMessageRef(v.into_static())
1510 }
1511 SubjectStatusViewRecordSubject::Unknown(v) => {
1512 SubjectStatusViewRecordSubject::Unknown(v.into_static())
1513 }
1514 }
1515 }
1516}
1517
1518impl jacquard_common::IntoStatic for SubjectStatusView<'_> {
1519 type Output = SubjectStatusView<'static>;
1520 fn into_static(self) -> Self::Output {
1521 SubjectStatusView {
1522 account_stats: self.account_stats.into_static(),
1523 age_assurance_state: self.age_assurance_state.into_static(),
1524 age_assurance_updated_by: self.age_assurance_updated_by.into_static(),
1525 appealed: self.appealed.into_static(),
1526 comment: self.comment.into_static(),
1527 created_at: self.created_at.into_static(),
1528 hosting: self.hosting.into_static(),
1529 id: self.id.into_static(),
1530 last_appealed_at: self.last_appealed_at.into_static(),
1531 last_reported_at: self.last_reported_at.into_static(),
1532 last_reviewed_at: self.last_reviewed_at.into_static(),
1533 last_reviewed_by: self.last_reviewed_by.into_static(),
1534 mute_reporting_until: self.mute_reporting_until.into_static(),
1535 mute_until: self.mute_until.into_static(),
1536 priority_score: self.priority_score.into_static(),
1537 records_stats: self.records_stats.into_static(),
1538 review_state: self.review_state.into_static(),
1539 subject: self.subject.into_static(),
1540 subject_blob_cids: self.subject_blob_cids.into_static(),
1541 subject_repo_handle: self.subject_repo_handle.into_static(),
1542 suspend_until: self.suspend_until.into_static(),
1543 tags: self.tags.into_static(),
1544 takendown: self.takendown.into_static(),
1545 updated_at: self.updated_at.into_static(),
1546 extra_data: self.extra_data.into_static(),
1547 }
1548 }
1549}
1550
1551///Detailed view of a subject. For record subjects, the author's repo and profile will be returned.
1552#[jacquard_derive::lexicon]
1553#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
1554#[serde(rename_all = "camelCase")]
1555pub struct SubjectView<'a> {
1556 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1557 #[serde(borrow)]
1558 pub profile: std::option::Option<SubjectViewRecordProfile<'a>>,
1559 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1560 #[serde(borrow)]
1561 pub record: std::option::Option<
1562 crate::tools_ozone::moderation::RecordViewDetail<'a>,
1563 >,
1564 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1565 #[serde(borrow)]
1566 pub repo: std::option::Option<crate::tools_ozone::moderation::RepoViewDetail<'a>>,
1567 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1568 #[serde(borrow)]
1569 pub status: std::option::Option<
1570 crate::tools_ozone::moderation::SubjectStatusView<'a>,
1571 >,
1572 #[serde(borrow)]
1573 pub subject: jacquard_common::CowStr<'a>,
1574 #[serde(borrow)]
1575 pub r#type: crate::com_atproto::moderation::SubjectType<'a>,
1576}
1577
1578#[jacquard_derive::open_union]
1579#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
1580#[serde(tag = "$type")]
1581#[serde(bound(deserialize = "'de: 'a"))]
1582pub enum SubjectViewRecordProfile<'a> {}
1583impl jacquard_common::IntoStatic for SubjectViewRecordProfile<'_> {
1584 type Output = SubjectViewRecordProfile<'static>;
1585 fn into_static(self) -> Self::Output {
1586 match self {
1587 SubjectViewRecordProfile::Unknown(v) => {
1588 SubjectViewRecordProfile::Unknown(v.into_static())
1589 }
1590 }
1591 }
1592}
1593
1594impl jacquard_common::IntoStatic for SubjectView<'_> {
1595 type Output = SubjectView<'static>;
1596 fn into_static(self) -> Self::Output {
1597 SubjectView {
1598 profile: self.profile.into_static(),
1599 record: self.record.into_static(),
1600 repo: self.repo.into_static(),
1601 status: self.status.into_static(),
1602 subject: self.subject.into_static(),
1603 r#type: self.r#type.into_static(),
1604 extra_data: self.extra_data.into_static(),
1605 }
1606 }
1607}
1608
1609#[jacquard_derive::lexicon]
1610#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
1611#[serde(rename_all = "camelCase")]
1612pub struct VideoDetails<'a> {
1613 pub height: i64,
1614 pub length: i64,
1615 pub width: i64,
1616}
1617
1618impl jacquard_common::IntoStatic for VideoDetails<'_> {
1619 type Output = VideoDetails<'static>;
1620 fn into_static(self) -> Self::Output {
1621 VideoDetails {
1622 height: self.height.into_static(),
1623 length: self.length.into_static(),
1624 width: self.width.into_static(),
1625 extra_data: self.extra_data.into_static(),
1626 }
1627 }
1628}