1pub mod describe_feed_generator;
9pub mod generator;
10pub mod get_actor_feeds;
11pub mod get_actor_likes;
12pub mod get_author_feed;
13pub mod get_feed;
14pub mod get_feed_generator;
15pub mod get_feed_generators;
16pub mod get_feed_skeleton;
17pub mod get_likes;
18pub mod get_list_feed;
19pub mod get_post_thread;
20pub mod get_posts;
21pub mod get_quotes;
22pub mod get_reposted_by;
23pub mod get_suggested_feeds;
24pub mod get_timeline;
25pub mod like;
26pub mod post;
27pub mod postgate;
28pub mod repost;
29pub mod search_posts;
30pub mod send_interactions;
31pub mod threadgate;
32
33#[jacquard_derive::lexicon]
34#[derive(
35 serde::Serialize,
36 serde::Deserialize,
37 Debug,
38 Clone,
39 PartialEq,
40 Eq,
41 jacquard_derive::IntoStatic
42)]
43#[serde(rename_all = "camelCase")]
44pub struct BlockedAuthor<'a> {
45 #[serde(borrow)]
46 pub did: jacquard_common::types::string::Did<'a>,
47 #[serde(skip_serializing_if = "std::option::Option::is_none")]
48 #[serde(borrow)]
49 pub viewer: std::option::Option<crate::app_bsky::actor::ViewerState<'a>>,
50}
51
52#[jacquard_derive::lexicon]
53#[derive(
54 serde::Serialize,
55 serde::Deserialize,
56 Debug,
57 Clone,
58 PartialEq,
59 Eq,
60 jacquard_derive::IntoStatic
61)]
62#[serde(rename_all = "camelCase")]
63pub struct BlockedPost<'a> {
64 #[serde(borrow)]
65 pub author: crate::app_bsky::feed::BlockedAuthor<'a>,
66 pub blocked: bool,
67 #[serde(borrow)]
68 pub uri: jacquard_common::types::string::AtUri<'a>,
69}
70
71#[derive(
73 serde::Serialize,
74 serde::Deserialize,
75 Debug,
76 Clone,
77 PartialEq,
78 Eq,
79 Hash,
80 jacquard_derive::IntoStatic
81)]
82pub struct ClickthroughAuthor;
83impl std::fmt::Display for ClickthroughAuthor {
84 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
85 write!(f, "clickthroughAuthor")
86 }
87}
88
89#[derive(
91 serde::Serialize,
92 serde::Deserialize,
93 Debug,
94 Clone,
95 PartialEq,
96 Eq,
97 Hash,
98 jacquard_derive::IntoStatic
99)]
100pub struct ClickthroughEmbed;
101impl std::fmt::Display for ClickthroughEmbed {
102 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
103 write!(f, "clickthroughEmbed")
104 }
105}
106
107#[derive(
109 serde::Serialize,
110 serde::Deserialize,
111 Debug,
112 Clone,
113 PartialEq,
114 Eq,
115 Hash,
116 jacquard_derive::IntoStatic
117)]
118pub struct ClickthroughItem;
119impl std::fmt::Display for ClickthroughItem {
120 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
121 write!(f, "clickthroughItem")
122 }
123}
124
125#[derive(
127 serde::Serialize,
128 serde::Deserialize,
129 Debug,
130 Clone,
131 PartialEq,
132 Eq,
133 Hash,
134 jacquard_derive::IntoStatic
135)]
136pub struct ClickthroughReposter;
137impl std::fmt::Display for ClickthroughReposter {
138 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
139 write!(f, "clickthroughReposter")
140 }
141}
142
143#[derive(
145 serde::Serialize,
146 serde::Deserialize,
147 Debug,
148 Clone,
149 PartialEq,
150 Eq,
151 Hash,
152 jacquard_derive::IntoStatic
153)]
154pub struct ContentModeUnspecified;
155impl std::fmt::Display for ContentModeUnspecified {
156 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
157 write!(f, "contentModeUnspecified")
158 }
159}
160
161#[derive(
163 serde::Serialize,
164 serde::Deserialize,
165 Debug,
166 Clone,
167 PartialEq,
168 Eq,
169 Hash,
170 jacquard_derive::IntoStatic
171)]
172pub struct ContentModeVideo;
173impl std::fmt::Display for ContentModeVideo {
174 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
175 write!(f, "contentModeVideo")
176 }
177}
178
179#[jacquard_derive::lexicon]
180#[derive(
181 serde::Serialize,
182 serde::Deserialize,
183 Debug,
184 Clone,
185 PartialEq,
186 Eq,
187 jacquard_derive::IntoStatic
188)]
189#[serde(rename_all = "camelCase")]
190pub struct FeedViewPost<'a> {
191 #[serde(skip_serializing_if = "std::option::Option::is_none")]
193 #[serde(borrow)]
194 pub feed_context: std::option::Option<jacquard_common::CowStr<'a>>,
195 #[serde(borrow)]
196 pub post: crate::app_bsky::feed::PostView<'a>,
197 #[serde(skip_serializing_if = "std::option::Option::is_none")]
198 #[serde(borrow)]
199 pub reason: std::option::Option<FeedViewPostReason<'a>>,
200 #[serde(skip_serializing_if = "std::option::Option::is_none")]
201 #[serde(borrow)]
202 pub reply: std::option::Option<crate::app_bsky::feed::ReplyRef<'a>>,
203 #[serde(skip_serializing_if = "std::option::Option::is_none")]
205 #[serde(borrow)]
206 pub req_id: std::option::Option<jacquard_common::CowStr<'a>>,
207}
208
209#[jacquard_derive::open_union]
210#[derive(
211 serde::Serialize,
212 serde::Deserialize,
213 Debug,
214 Clone,
215 PartialEq,
216 Eq,
217 jacquard_derive::IntoStatic
218)]
219#[serde(tag = "$type")]
220#[serde(bound(deserialize = "'de: 'a"))]
221pub enum FeedViewPostReason<'a> {
222 #[serde(rename = "app.bsky.feed.defs#reasonRepost")]
223 ReasonRepost(Box<crate::app_bsky::feed::ReasonRepost<'a>>),
224 #[serde(rename = "app.bsky.feed.defs#reasonPin")]
225 ReasonPin(Box<crate::app_bsky::feed::ReasonPin<'a>>),
226}
227
228#[jacquard_derive::lexicon]
229#[derive(
230 serde::Serialize,
231 serde::Deserialize,
232 Debug,
233 Clone,
234 PartialEq,
235 Eq,
236 jacquard_derive::IntoStatic
237)]
238#[serde(rename_all = "camelCase")]
239pub struct GeneratorView<'a> {
240 #[serde(skip_serializing_if = "std::option::Option::is_none")]
241 pub accepts_interactions: std::option::Option<bool>,
242 #[serde(skip_serializing_if = "std::option::Option::is_none")]
243 #[serde(borrow)]
244 pub avatar: std::option::Option<jacquard_common::types::string::Uri<'a>>,
245 #[serde(borrow)]
246 pub cid: jacquard_common::types::string::Cid<'a>,
247 #[serde(skip_serializing_if = "std::option::Option::is_none")]
248 #[serde(borrow)]
249 pub content_mode: std::option::Option<jacquard_common::CowStr<'a>>,
250 #[serde(borrow)]
251 pub creator: crate::app_bsky::actor::ProfileView<'a>,
252 #[serde(skip_serializing_if = "std::option::Option::is_none")]
253 #[serde(borrow)]
254 pub description: std::option::Option<jacquard_common::CowStr<'a>>,
255 #[serde(skip_serializing_if = "std::option::Option::is_none")]
256 #[serde(borrow)]
257 pub description_facets: std::option::Option<
258 Vec<crate::app_bsky::richtext::facet::Facet<'a>>,
259 >,
260 #[serde(borrow)]
261 pub did: jacquard_common::types::string::Did<'a>,
262 #[serde(borrow)]
263 pub display_name: jacquard_common::CowStr<'a>,
264 pub indexed_at: jacquard_common::types::string::Datetime,
265 #[serde(skip_serializing_if = "std::option::Option::is_none")]
266 #[serde(borrow)]
267 pub labels: std::option::Option<Vec<crate::com_atproto::label::Label<'a>>>,
268 #[serde(skip_serializing_if = "std::option::Option::is_none")]
269 pub like_count: std::option::Option<i64>,
270 #[serde(borrow)]
271 pub uri: jacquard_common::types::string::AtUri<'a>,
272 #[serde(skip_serializing_if = "std::option::Option::is_none")]
273 #[serde(borrow)]
274 pub viewer: std::option::Option<crate::app_bsky::feed::GeneratorViewerState<'a>>,
275}
276
277#[jacquard_derive::lexicon]
278#[derive(
279 serde::Serialize,
280 serde::Deserialize,
281 Debug,
282 Clone,
283 PartialEq,
284 Eq,
285 jacquard_derive::IntoStatic
286)]
287#[serde(rename_all = "camelCase")]
288pub struct GeneratorViewerState<'a> {
289 #[serde(skip_serializing_if = "std::option::Option::is_none")]
290 #[serde(borrow)]
291 pub like: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
292}
293
294#[jacquard_derive::lexicon]
295#[derive(
296 serde::Serialize,
297 serde::Deserialize,
298 Debug,
299 Clone,
300 PartialEq,
301 Eq,
302 jacquard_derive::IntoStatic
303)]
304#[serde(rename_all = "camelCase")]
305pub struct Interaction<'a> {
306 #[serde(skip_serializing_if = "std::option::Option::is_none")]
307 #[serde(borrow)]
308 pub event: std::option::Option<jacquard_common::CowStr<'a>>,
309 #[serde(skip_serializing_if = "std::option::Option::is_none")]
311 #[serde(borrow)]
312 pub feed_context: std::option::Option<jacquard_common::CowStr<'a>>,
313 #[serde(skip_serializing_if = "std::option::Option::is_none")]
314 #[serde(borrow)]
315 pub item: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
316 #[serde(skip_serializing_if = "std::option::Option::is_none")]
318 #[serde(borrow)]
319 pub req_id: std::option::Option<jacquard_common::CowStr<'a>>,
320}
321
322#[derive(
324 serde::Serialize,
325 serde::Deserialize,
326 Debug,
327 Clone,
328 PartialEq,
329 Eq,
330 Hash,
331 jacquard_derive::IntoStatic
332)]
333pub struct InteractionLike;
334impl std::fmt::Display for InteractionLike {
335 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
336 write!(f, "interactionLike")
337 }
338}
339
340#[derive(
342 serde::Serialize,
343 serde::Deserialize,
344 Debug,
345 Clone,
346 PartialEq,
347 Eq,
348 Hash,
349 jacquard_derive::IntoStatic
350)]
351pub struct InteractionQuote;
352impl std::fmt::Display for InteractionQuote {
353 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
354 write!(f, "interactionQuote")
355 }
356}
357
358#[derive(
360 serde::Serialize,
361 serde::Deserialize,
362 Debug,
363 Clone,
364 PartialEq,
365 Eq,
366 Hash,
367 jacquard_derive::IntoStatic
368)]
369pub struct InteractionReply;
370impl std::fmt::Display for InteractionReply {
371 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
372 write!(f, "interactionReply")
373 }
374}
375
376#[derive(
378 serde::Serialize,
379 serde::Deserialize,
380 Debug,
381 Clone,
382 PartialEq,
383 Eq,
384 Hash,
385 jacquard_derive::IntoStatic
386)]
387pub struct InteractionRepost;
388impl std::fmt::Display for InteractionRepost {
389 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
390 write!(f, "interactionRepost")
391 }
392}
393
394#[derive(
396 serde::Serialize,
397 serde::Deserialize,
398 Debug,
399 Clone,
400 PartialEq,
401 Eq,
402 Hash,
403 jacquard_derive::IntoStatic
404)]
405pub struct InteractionSeen;
406impl std::fmt::Display for InteractionSeen {
407 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
408 write!(f, "interactionSeen")
409 }
410}
411
412#[derive(
414 serde::Serialize,
415 serde::Deserialize,
416 Debug,
417 Clone,
418 PartialEq,
419 Eq,
420 Hash,
421 jacquard_derive::IntoStatic
422)]
423pub struct InteractionShare;
424impl std::fmt::Display for InteractionShare {
425 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
426 write!(f, "interactionShare")
427 }
428}
429
430#[jacquard_derive::lexicon]
431#[derive(
432 serde::Serialize,
433 serde::Deserialize,
434 Debug,
435 Clone,
436 PartialEq,
437 Eq,
438 jacquard_derive::IntoStatic
439)]
440#[serde(rename_all = "camelCase")]
441pub struct NotFoundPost<'a> {
442 pub not_found: bool,
443 #[serde(borrow)]
444 pub uri: jacquard_common::types::string::AtUri<'a>,
445}
446
447#[jacquard_derive::lexicon]
448#[derive(
449 serde::Serialize,
450 serde::Deserialize,
451 Debug,
452 Clone,
453 PartialEq,
454 Eq,
455 jacquard_derive::IntoStatic
456)]
457#[serde(rename_all = "camelCase")]
458pub struct PostView<'a> {
459 #[serde(borrow)]
460 pub author: crate::app_bsky::actor::ProfileViewBasic<'a>,
461 #[serde(skip_serializing_if = "std::option::Option::is_none")]
462 pub bookmark_count: std::option::Option<i64>,
463 #[serde(borrow)]
464 pub cid: jacquard_common::types::string::Cid<'a>,
465 #[serde(skip_serializing_if = "std::option::Option::is_none")]
466 #[serde(borrow)]
467 pub embed: std::option::Option<PostViewEmbed<'a>>,
468 pub indexed_at: jacquard_common::types::string::Datetime,
469 #[serde(skip_serializing_if = "std::option::Option::is_none")]
470 #[serde(borrow)]
471 pub labels: std::option::Option<Vec<crate::com_atproto::label::Label<'a>>>,
472 #[serde(skip_serializing_if = "std::option::Option::is_none")]
473 pub like_count: std::option::Option<i64>,
474 #[serde(skip_serializing_if = "std::option::Option::is_none")]
475 pub quote_count: std::option::Option<i64>,
476 #[serde(borrow)]
477 pub record: jacquard_common::types::value::Data<'a>,
478 #[serde(skip_serializing_if = "std::option::Option::is_none")]
479 pub reply_count: std::option::Option<i64>,
480 #[serde(skip_serializing_if = "std::option::Option::is_none")]
481 pub repost_count: std::option::Option<i64>,
482 #[serde(skip_serializing_if = "std::option::Option::is_none")]
483 #[serde(borrow)]
484 pub threadgate: std::option::Option<crate::app_bsky::feed::ThreadgateView<'a>>,
485 #[serde(borrow)]
486 pub uri: jacquard_common::types::string::AtUri<'a>,
487 #[serde(skip_serializing_if = "std::option::Option::is_none")]
488 #[serde(borrow)]
489 pub viewer: std::option::Option<crate::app_bsky::feed::ViewerState<'a>>,
490}
491
492#[jacquard_derive::open_union]
493#[derive(
494 serde::Serialize,
495 serde::Deserialize,
496 Debug,
497 Clone,
498 PartialEq,
499 Eq,
500 jacquard_derive::IntoStatic
501)]
502#[serde(tag = "$type")]
503#[serde(bound(deserialize = "'de: 'a"))]
504pub enum PostViewEmbed<'a> {
505 #[serde(rename = "app.bsky.embed.images#view")]
506 ImagesView(Box<crate::app_bsky::embed::images::View<'a>>),
507 #[serde(rename = "app.bsky.embed.video#view")]
508 VideoView(Box<crate::app_bsky::embed::video::View<'a>>),
509 #[serde(rename = "app.bsky.embed.external#view")]
510 ExternalView(Box<crate::app_bsky::embed::external::View<'a>>),
511 #[serde(rename = "app.bsky.embed.record#view")]
512 RecordView(Box<crate::app_bsky::embed::record::View<'a>>),
513 #[serde(rename = "app.bsky.embed.recordWithMedia#view")]
514 RecordWithMediaView(Box<crate::app_bsky::embed::record_with_media::View<'a>>),
515}
516
517#[jacquard_derive::lexicon]
518#[derive(
519 serde::Serialize,
520 serde::Deserialize,
521 Debug,
522 Clone,
523 PartialEq,
524 Eq,
525 jacquard_derive::IntoStatic
526)]
527#[serde(rename_all = "camelCase")]
528pub struct ReasonPin<'a> {}
529#[jacquard_derive::lexicon]
530#[derive(
531 serde::Serialize,
532 serde::Deserialize,
533 Debug,
534 Clone,
535 PartialEq,
536 Eq,
537 jacquard_derive::IntoStatic
538)]
539#[serde(rename_all = "camelCase")]
540pub struct ReasonRepost<'a> {
541 #[serde(borrow)]
542 pub by: crate::app_bsky::actor::ProfileViewBasic<'a>,
543 #[serde(skip_serializing_if = "std::option::Option::is_none")]
544 #[serde(borrow)]
545 pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>,
546 pub indexed_at: jacquard_common::types::string::Datetime,
547 #[serde(skip_serializing_if = "std::option::Option::is_none")]
548 #[serde(borrow)]
549 pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
550}
551
552#[jacquard_derive::lexicon]
553#[derive(
554 serde::Serialize,
555 serde::Deserialize,
556 Debug,
557 Clone,
558 PartialEq,
559 Eq,
560 jacquard_derive::IntoStatic
561)]
562#[serde(rename_all = "camelCase")]
563pub struct ReplyRef<'a> {
564 #[serde(skip_serializing_if = "std::option::Option::is_none")]
566 #[serde(borrow)]
567 pub grandparent_author: std::option::Option<
568 crate::app_bsky::actor::ProfileViewBasic<'a>,
569 >,
570 #[serde(borrow)]
571 pub parent: ReplyRefParent<'a>,
572 #[serde(borrow)]
573 pub root: ReplyRefRoot<'a>,
574}
575
576#[jacquard_derive::open_union]
577#[derive(
578 serde::Serialize,
579 serde::Deserialize,
580 Debug,
581 Clone,
582 PartialEq,
583 Eq,
584 jacquard_derive::IntoStatic
585)]
586#[serde(tag = "$type")]
587#[serde(bound(deserialize = "'de: 'a"))]
588pub enum ReplyRefParent<'a> {
589 #[serde(rename = "app.bsky.feed.defs#postView")]
590 PostView(Box<crate::app_bsky::feed::PostView<'a>>),
591 #[serde(rename = "app.bsky.feed.defs#notFoundPost")]
592 NotFoundPost(Box<crate::app_bsky::feed::NotFoundPost<'a>>),
593 #[serde(rename = "app.bsky.feed.defs#blockedPost")]
594 BlockedPost(Box<crate::app_bsky::feed::BlockedPost<'a>>),
595}
596
597#[jacquard_derive::open_union]
598#[derive(
599 serde::Serialize,
600 serde::Deserialize,
601 Debug,
602 Clone,
603 PartialEq,
604 Eq,
605 jacquard_derive::IntoStatic
606)]
607#[serde(tag = "$type")]
608#[serde(bound(deserialize = "'de: 'a"))]
609pub enum ReplyRefRoot<'a> {
610 #[serde(rename = "app.bsky.feed.defs#postView")]
611 PostView(Box<crate::app_bsky::feed::PostView<'a>>),
612 #[serde(rename = "app.bsky.feed.defs#notFoundPost")]
613 NotFoundPost(Box<crate::app_bsky::feed::NotFoundPost<'a>>),
614 #[serde(rename = "app.bsky.feed.defs#blockedPost")]
615 BlockedPost(Box<crate::app_bsky::feed::BlockedPost<'a>>),
616}
617
618#[derive(
620 serde::Serialize,
621 serde::Deserialize,
622 Debug,
623 Clone,
624 PartialEq,
625 Eq,
626 Hash,
627 jacquard_derive::IntoStatic
628)]
629pub struct RequestLess;
630impl std::fmt::Display for RequestLess {
631 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
632 write!(f, "requestLess")
633 }
634}
635
636#[derive(
638 serde::Serialize,
639 serde::Deserialize,
640 Debug,
641 Clone,
642 PartialEq,
643 Eq,
644 Hash,
645 jacquard_derive::IntoStatic
646)]
647pub struct RequestMore;
648impl std::fmt::Display for RequestMore {
649 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
650 write!(f, "requestMore")
651 }
652}
653
654#[jacquard_derive::lexicon]
655#[derive(
656 serde::Serialize,
657 serde::Deserialize,
658 Debug,
659 Clone,
660 PartialEq,
661 Eq,
662 jacquard_derive::IntoStatic
663)]
664#[serde(rename_all = "camelCase")]
665pub struct SkeletonFeedPost<'a> {
666 #[serde(skip_serializing_if = "std::option::Option::is_none")]
668 #[serde(borrow)]
669 pub feed_context: std::option::Option<jacquard_common::CowStr<'a>>,
670 #[serde(borrow)]
671 pub post: jacquard_common::types::string::AtUri<'a>,
672 #[serde(skip_serializing_if = "std::option::Option::is_none")]
673 #[serde(borrow)]
674 pub reason: std::option::Option<SkeletonFeedPostReason<'a>>,
675}
676
677#[jacquard_derive::open_union]
678#[derive(
679 serde::Serialize,
680 serde::Deserialize,
681 Debug,
682 Clone,
683 PartialEq,
684 Eq,
685 jacquard_derive::IntoStatic
686)]
687#[serde(tag = "$type")]
688#[serde(bound(deserialize = "'de: 'a"))]
689pub enum SkeletonFeedPostReason<'a> {
690 #[serde(rename = "app.bsky.feed.defs#skeletonReasonRepost")]
691 SkeletonReasonRepost(Box<crate::app_bsky::feed::SkeletonReasonRepost<'a>>),
692 #[serde(rename = "app.bsky.feed.defs#skeletonReasonPin")]
693 SkeletonReasonPin(Box<crate::app_bsky::feed::SkeletonReasonPin<'a>>),
694}
695
696#[jacquard_derive::lexicon]
697#[derive(
698 serde::Serialize,
699 serde::Deserialize,
700 Debug,
701 Clone,
702 PartialEq,
703 Eq,
704 jacquard_derive::IntoStatic
705)]
706#[serde(rename_all = "camelCase")]
707pub struct SkeletonReasonPin<'a> {}
708#[jacquard_derive::lexicon]
709#[derive(
710 serde::Serialize,
711 serde::Deserialize,
712 Debug,
713 Clone,
714 PartialEq,
715 Eq,
716 jacquard_derive::IntoStatic
717)]
718#[serde(rename_all = "camelCase")]
719pub struct SkeletonReasonRepost<'a> {
720 #[serde(borrow)]
721 pub repost: jacquard_common::types::string::AtUri<'a>,
722}
723
724#[jacquard_derive::lexicon]
726#[derive(
727 serde::Serialize,
728 serde::Deserialize,
729 Debug,
730 Clone,
731 PartialEq,
732 Eq,
733 jacquard_derive::IntoStatic
734)]
735#[serde(rename_all = "camelCase")]
736pub struct ThreadContext<'a> {
737 #[serde(skip_serializing_if = "std::option::Option::is_none")]
738 #[serde(borrow)]
739 pub root_author_like: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
740}
741
742#[jacquard_derive::lexicon]
743#[derive(
744 serde::Serialize,
745 serde::Deserialize,
746 Debug,
747 Clone,
748 PartialEq,
749 Eq,
750 jacquard_derive::IntoStatic
751)]
752#[serde(rename_all = "camelCase")]
753pub struct ThreadViewPost<'a> {
754 #[serde(skip_serializing_if = "std::option::Option::is_none")]
755 #[serde(borrow)]
756 pub parent: std::option::Option<ThreadViewPostParent<'a>>,
757 #[serde(borrow)]
758 pub post: crate::app_bsky::feed::PostView<'a>,
759 #[serde(skip_serializing_if = "std::option::Option::is_none")]
760 #[serde(borrow)]
761 pub replies: std::option::Option<Vec<ThreadViewPostRepliesItem<'a>>>,
762 #[serde(skip_serializing_if = "std::option::Option::is_none")]
763 #[serde(borrow)]
764 pub thread_context: std::option::Option<crate::app_bsky::feed::ThreadContext<'a>>,
765}
766
767#[jacquard_derive::open_union]
768#[derive(
769 serde::Serialize,
770 serde::Deserialize,
771 Debug,
772 Clone,
773 PartialEq,
774 Eq,
775 jacquard_derive::IntoStatic
776)]
777#[serde(tag = "$type")]
778#[serde(bound(deserialize = "'de: 'a"))]
779pub enum ThreadViewPostParent<'a> {
780 #[serde(rename = "app.bsky.feed.defs#threadViewPost")]
781 ThreadViewPost(Box<crate::app_bsky::feed::ThreadViewPost<'a>>),
782 #[serde(rename = "app.bsky.feed.defs#notFoundPost")]
783 NotFoundPost(Box<crate::app_bsky::feed::NotFoundPost<'a>>),
784 #[serde(rename = "app.bsky.feed.defs#blockedPost")]
785 BlockedPost(Box<crate::app_bsky::feed::BlockedPost<'a>>),
786}
787
788#[jacquard_derive::open_union]
789#[derive(
790 serde::Serialize,
791 serde::Deserialize,
792 Debug,
793 Clone,
794 PartialEq,
795 Eq,
796 jacquard_derive::IntoStatic
797)]
798#[serde(tag = "$type")]
799#[serde(bound(deserialize = "'de: 'a"))]
800pub enum ThreadViewPostRepliesItem<'a> {
801 #[serde(rename = "app.bsky.feed.defs#threadViewPost")]
802 ThreadViewPost(Box<crate::app_bsky::feed::ThreadViewPost<'a>>),
803 #[serde(rename = "app.bsky.feed.defs#notFoundPost")]
804 NotFoundPost(Box<crate::app_bsky::feed::NotFoundPost<'a>>),
805 #[serde(rename = "app.bsky.feed.defs#blockedPost")]
806 BlockedPost(Box<crate::app_bsky::feed::BlockedPost<'a>>),
807}
808
809#[jacquard_derive::lexicon]
810#[derive(
811 serde::Serialize,
812 serde::Deserialize,
813 Debug,
814 Clone,
815 PartialEq,
816 Eq,
817 jacquard_derive::IntoStatic
818)]
819#[serde(rename_all = "camelCase")]
820pub struct ThreadgateView<'a> {
821 #[serde(skip_serializing_if = "std::option::Option::is_none")]
822 #[serde(borrow)]
823 pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>,
824 #[serde(skip_serializing_if = "std::option::Option::is_none")]
825 #[serde(borrow)]
826 pub lists: std::option::Option<Vec<crate::app_bsky::graph::ListViewBasic<'a>>>,
827 #[serde(skip_serializing_if = "std::option::Option::is_none")]
828 #[serde(borrow)]
829 pub record: std::option::Option<jacquard_common::types::value::Data<'a>>,
830 #[serde(skip_serializing_if = "std::option::Option::is_none")]
831 #[serde(borrow)]
832 pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
833}
834
835#[jacquard_derive::lexicon]
837#[derive(
838 serde::Serialize,
839 serde::Deserialize,
840 Debug,
841 Clone,
842 PartialEq,
843 Eq,
844 jacquard_derive::IntoStatic
845)]
846#[serde(rename_all = "camelCase")]
847pub struct ViewerState<'a> {
848 #[serde(skip_serializing_if = "std::option::Option::is_none")]
849 pub bookmarked: std::option::Option<bool>,
850 #[serde(skip_serializing_if = "std::option::Option::is_none")]
851 pub embedding_disabled: std::option::Option<bool>,
852 #[serde(skip_serializing_if = "std::option::Option::is_none")]
853 #[serde(borrow)]
854 pub like: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
855 #[serde(skip_serializing_if = "std::option::Option::is_none")]
856 pub pinned: std::option::Option<bool>,
857 #[serde(skip_serializing_if = "std::option::Option::is_none")]
858 pub reply_disabled: std::option::Option<bool>,
859 #[serde(skip_serializing_if = "std::option::Option::is_none")]
860 #[serde(borrow)]
861 pub repost: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
862 #[serde(skip_serializing_if = "std::option::Option::is_none")]
863 pub thread_muted: std::option::Option<bool>,
864}