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: Option<crate::app_bsky::actor::ViewerState<'a>>,
50}
51
52pub mod blocked_author_state {
53
54 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
55 #[allow(unused)]
56 use ::core::marker::PhantomData;
57 mod sealed {
58 pub trait Sealed {}
59 }
60 pub trait State: sealed::Sealed {
62 type Did;
63 }
64 pub struct Empty(());
66 impl sealed::Sealed for Empty {}
67 impl State for Empty {
68 type Did = Unset;
69 }
70 pub struct SetDid<S: State = Empty>(PhantomData<fn() -> S>);
72 impl<S: State> sealed::Sealed for SetDid<S> {}
73 impl<S: State> State for SetDid<S> {
74 type Did = Set<members::did>;
75 }
76 #[allow(non_camel_case_types)]
78 pub mod members {
79 pub struct did(());
81 }
82}
83
84pub struct BlockedAuthorBuilder<'a, S: blocked_author_state::State> {
86 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
87 __unsafe_private_named: (
88 ::core::option::Option<jacquard_common::types::string::Did<'a>>,
89 ::core::option::Option<crate::app_bsky::actor::ViewerState<'a>>,
90 ),
91 _phantom: ::core::marker::PhantomData<&'a ()>,
92}
93
94impl<'a> BlockedAuthor<'a> {
95 pub fn new() -> BlockedAuthorBuilder<'a, blocked_author_state::Empty> {
97 BlockedAuthorBuilder::new()
98 }
99}
100
101impl<'a> BlockedAuthorBuilder<'a, blocked_author_state::Empty> {
102 pub fn new() -> Self {
104 BlockedAuthorBuilder {
105 _phantom_state: ::core::marker::PhantomData,
106 __unsafe_private_named: (None, None),
107 _phantom: ::core::marker::PhantomData,
108 }
109 }
110}
111
112impl<'a, S> BlockedAuthorBuilder<'a, S>
113where
114 S: blocked_author_state::State,
115 S::Did: blocked_author_state::IsUnset,
116{
117 pub fn did(
119 mut self,
120 value: impl Into<jacquard_common::types::string::Did<'a>>,
121 ) -> BlockedAuthorBuilder<'a, blocked_author_state::SetDid<S>> {
122 self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
123 BlockedAuthorBuilder {
124 _phantom_state: ::core::marker::PhantomData,
125 __unsafe_private_named: self.__unsafe_private_named,
126 _phantom: ::core::marker::PhantomData,
127 }
128 }
129}
130
131impl<'a, S: blocked_author_state::State> BlockedAuthorBuilder<'a, S> {
132 pub fn viewer(
134 mut self,
135 value: impl Into<Option<crate::app_bsky::actor::ViewerState<'a>>>,
136 ) -> Self {
137 self.__unsafe_private_named.1 = value.into();
138 self
139 }
140 pub fn maybe_viewer(
142 mut self,
143 value: Option<crate::app_bsky::actor::ViewerState<'a>>,
144 ) -> Self {
145 self.__unsafe_private_named.1 = value;
146 self
147 }
148}
149
150impl<'a, S> BlockedAuthorBuilder<'a, S>
151where
152 S: blocked_author_state::State,
153 S::Did: blocked_author_state::IsSet,
154{
155 pub fn build(self) -> BlockedAuthor<'a> {
157 BlockedAuthor {
158 did: self.__unsafe_private_named.0.unwrap(),
159 viewer: self.__unsafe_private_named.1,
160 extra_data: Default::default(),
161 }
162 }
163 pub fn build_with_data(
165 self,
166 extra_data: std::collections::BTreeMap<
167 jacquard_common::smol_str::SmolStr,
168 jacquard_common::types::value::Data<'a>,
169 >,
170 ) -> BlockedAuthor<'a> {
171 BlockedAuthor {
172 did: self.__unsafe_private_named.0.unwrap(),
173 viewer: self.__unsafe_private_named.1,
174 extra_data: Some(extra_data),
175 }
176 }
177}
178
179fn lexicon_doc_app_bsky_feed_defs() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
180 ::jacquard_lexicon::lexicon::LexiconDoc {
181 lexicon: ::jacquard_lexicon::lexicon::Lexicon::Lexicon1,
182 id: ::jacquard_common::CowStr::new_static("app.bsky.feed.defs"),
183 revision: None,
184 description: None,
185 defs: {
186 let mut map = ::std::collections::BTreeMap::new();
187 map.insert(
188 ::jacquard_common::smol_str::SmolStr::new_static("blockedAuthor"),
189 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
190 description: None,
191 required: Some(
192 vec![::jacquard_common::smol_str::SmolStr::new_static("did")],
193 ),
194 nullable: None,
195 properties: {
196 #[allow(unused_mut)]
197 let mut map = ::std::collections::BTreeMap::new();
198 map.insert(
199 ::jacquard_common::smol_str::SmolStr::new_static("did"),
200 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
201 description: None,
202 format: Some(
203 ::jacquard_lexicon::lexicon::LexStringFormat::Did,
204 ),
205 default: None,
206 min_length: None,
207 max_length: None,
208 min_graphemes: None,
209 max_graphemes: None,
210 r#enum: None,
211 r#const: None,
212 known_values: None,
213 }),
214 );
215 map.insert(
216 ::jacquard_common::smol_str::SmolStr::new_static("viewer"),
217 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
218 description: None,
219 r#ref: ::jacquard_common::CowStr::new_static(
220 "app.bsky.actor.defs#viewerState",
221 ),
222 }),
223 );
224 map
225 },
226 }),
227 );
228 map.insert(
229 ::jacquard_common::smol_str::SmolStr::new_static("blockedPost"),
230 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
231 description: None,
232 required: Some(
233 vec![
234 ::jacquard_common::smol_str::SmolStr::new_static("uri"),
235 ::jacquard_common::smol_str::SmolStr::new_static("blocked"),
236 ::jacquard_common::smol_str::SmolStr::new_static("author")
237 ],
238 ),
239 nullable: None,
240 properties: {
241 #[allow(unused_mut)]
242 let mut map = ::std::collections::BTreeMap::new();
243 map.insert(
244 ::jacquard_common::smol_str::SmolStr::new_static("author"),
245 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
246 description: None,
247 r#ref: ::jacquard_common::CowStr::new_static(
248 "#blockedAuthor",
249 ),
250 }),
251 );
252 map.insert(
253 ::jacquard_common::smol_str::SmolStr::new_static("blocked"),
254 ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
255 description: None,
256 default: None,
257 r#const: None,
258 }),
259 );
260 map.insert(
261 ::jacquard_common::smol_str::SmolStr::new_static("uri"),
262 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
263 description: None,
264 format: Some(
265 ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
266 ),
267 default: None,
268 min_length: None,
269 max_length: None,
270 min_graphemes: None,
271 max_graphemes: None,
272 r#enum: None,
273 r#const: None,
274 known_values: None,
275 }),
276 );
277 map
278 },
279 }),
280 );
281 map.insert(
282 ::jacquard_common::smol_str::SmolStr::new_static("clickthroughAuthor"),
283 ::jacquard_lexicon::lexicon::LexUserType::Token(::jacquard_lexicon::lexicon::LexToken {
284 description: None,
285 }),
286 );
287 map.insert(
288 ::jacquard_common::smol_str::SmolStr::new_static("clickthroughEmbed"),
289 ::jacquard_lexicon::lexicon::LexUserType::Token(::jacquard_lexicon::lexicon::LexToken {
290 description: None,
291 }),
292 );
293 map.insert(
294 ::jacquard_common::smol_str::SmolStr::new_static("clickthroughItem"),
295 ::jacquard_lexicon::lexicon::LexUserType::Token(::jacquard_lexicon::lexicon::LexToken {
296 description: None,
297 }),
298 );
299 map.insert(
300 ::jacquard_common::smol_str::SmolStr::new_static("clickthroughReposter"),
301 ::jacquard_lexicon::lexicon::LexUserType::Token(::jacquard_lexicon::lexicon::LexToken {
302 description: None,
303 }),
304 );
305 map.insert(
306 ::jacquard_common::smol_str::SmolStr::new_static(
307 "contentModeUnspecified",
308 ),
309 ::jacquard_lexicon::lexicon::LexUserType::Token(::jacquard_lexicon::lexicon::LexToken {
310 description: None,
311 }),
312 );
313 map.insert(
314 ::jacquard_common::smol_str::SmolStr::new_static("contentModeVideo"),
315 ::jacquard_lexicon::lexicon::LexUserType::Token(::jacquard_lexicon::lexicon::LexToken {
316 description: None,
317 }),
318 );
319 map.insert(
320 ::jacquard_common::smol_str::SmolStr::new_static("feedViewPost"),
321 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
322 description: None,
323 required: Some(
324 vec![::jacquard_common::smol_str::SmolStr::new_static("post")],
325 ),
326 nullable: None,
327 properties: {
328 #[allow(unused_mut)]
329 let mut map = ::std::collections::BTreeMap::new();
330 map.insert(
331 ::jacquard_common::smol_str::SmolStr::new_static(
332 "feedContext",
333 ),
334 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
335 description: Some(
336 ::jacquard_common::CowStr::new_static(
337 "Context provided by feed generator that may be passed back alongside interactions.",
338 ),
339 ),
340 format: None,
341 default: None,
342 min_length: None,
343 max_length: Some(2000usize),
344 min_graphemes: None,
345 max_graphemes: None,
346 r#enum: None,
347 r#const: None,
348 known_values: None,
349 }),
350 );
351 map.insert(
352 ::jacquard_common::smol_str::SmolStr::new_static("post"),
353 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
354 description: None,
355 r#ref: ::jacquard_common::CowStr::new_static("#postView"),
356 }),
357 );
358 map.insert(
359 ::jacquard_common::smol_str::SmolStr::new_static("reason"),
360 ::jacquard_lexicon::lexicon::LexObjectProperty::Union(::jacquard_lexicon::lexicon::LexRefUnion {
361 description: None,
362 refs: vec![
363 ::jacquard_common::CowStr::new_static("#reasonRepost"),
364 ::jacquard_common::CowStr::new_static("#reasonPin")
365 ],
366 closed: None,
367 }),
368 );
369 map.insert(
370 ::jacquard_common::smol_str::SmolStr::new_static("reply"),
371 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
372 description: None,
373 r#ref: ::jacquard_common::CowStr::new_static("#replyRef"),
374 }),
375 );
376 map.insert(
377 ::jacquard_common::smol_str::SmolStr::new_static("reqId"),
378 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
379 description: Some(
380 ::jacquard_common::CowStr::new_static(
381 "Unique identifier per request that may be passed back alongside interactions.",
382 ),
383 ),
384 format: None,
385 default: None,
386 min_length: None,
387 max_length: Some(100usize),
388 min_graphemes: None,
389 max_graphemes: None,
390 r#enum: None,
391 r#const: None,
392 known_values: None,
393 }),
394 );
395 map
396 },
397 }),
398 );
399 map.insert(
400 ::jacquard_common::smol_str::SmolStr::new_static("generatorView"),
401 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
402 description: None,
403 required: Some(
404 vec![
405 ::jacquard_common::smol_str::SmolStr::new_static("uri"),
406 ::jacquard_common::smol_str::SmolStr::new_static("cid"),
407 ::jacquard_common::smol_str::SmolStr::new_static("did"),
408 ::jacquard_common::smol_str::SmolStr::new_static("creator"),
409 ::jacquard_common::smol_str::SmolStr::new_static("displayName"),
410 ::jacquard_common::smol_str::SmolStr::new_static("indexedAt")
411 ],
412 ),
413 nullable: None,
414 properties: {
415 #[allow(unused_mut)]
416 let mut map = ::std::collections::BTreeMap::new();
417 map.insert(
418 ::jacquard_common::smol_str::SmolStr::new_static(
419 "acceptsInteractions",
420 ),
421 ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
422 description: None,
423 default: None,
424 r#const: None,
425 }),
426 );
427 map.insert(
428 ::jacquard_common::smol_str::SmolStr::new_static("avatar"),
429 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
430 description: None,
431 format: Some(
432 ::jacquard_lexicon::lexicon::LexStringFormat::Uri,
433 ),
434 default: None,
435 min_length: None,
436 max_length: None,
437 min_graphemes: None,
438 max_graphemes: None,
439 r#enum: None,
440 r#const: None,
441 known_values: None,
442 }),
443 );
444 map.insert(
445 ::jacquard_common::smol_str::SmolStr::new_static("cid"),
446 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
447 description: None,
448 format: Some(
449 ::jacquard_lexicon::lexicon::LexStringFormat::Cid,
450 ),
451 default: None,
452 min_length: None,
453 max_length: None,
454 min_graphemes: None,
455 max_graphemes: None,
456 r#enum: None,
457 r#const: None,
458 known_values: None,
459 }),
460 );
461 map.insert(
462 ::jacquard_common::smol_str::SmolStr::new_static(
463 "contentMode",
464 ),
465 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
466 description: None,
467 format: None,
468 default: None,
469 min_length: None,
470 max_length: None,
471 min_graphemes: None,
472 max_graphemes: None,
473 r#enum: None,
474 r#const: None,
475 known_values: None,
476 }),
477 );
478 map.insert(
479 ::jacquard_common::smol_str::SmolStr::new_static("creator"),
480 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
481 description: None,
482 r#ref: ::jacquard_common::CowStr::new_static(
483 "app.bsky.actor.defs#profileView",
484 ),
485 }),
486 );
487 map.insert(
488 ::jacquard_common::smol_str::SmolStr::new_static(
489 "description",
490 ),
491 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
492 description: None,
493 format: None,
494 default: None,
495 min_length: None,
496 max_length: Some(3000usize),
497 min_graphemes: None,
498 max_graphemes: Some(300usize),
499 r#enum: None,
500 r#const: None,
501 known_values: None,
502 }),
503 );
504 map.insert(
505 ::jacquard_common::smol_str::SmolStr::new_static(
506 "descriptionFacets",
507 ),
508 ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
509 description: None,
510 items: ::jacquard_lexicon::lexicon::LexArrayItem::Ref(::jacquard_lexicon::lexicon::LexRef {
511 description: None,
512 r#ref: ::jacquard_common::CowStr::new_static(
513 "app.bsky.richtext.facet",
514 ),
515 }),
516 min_length: None,
517 max_length: None,
518 }),
519 );
520 map.insert(
521 ::jacquard_common::smol_str::SmolStr::new_static("did"),
522 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
523 description: None,
524 format: Some(
525 ::jacquard_lexicon::lexicon::LexStringFormat::Did,
526 ),
527 default: None,
528 min_length: None,
529 max_length: None,
530 min_graphemes: None,
531 max_graphemes: None,
532 r#enum: None,
533 r#const: None,
534 known_values: None,
535 }),
536 );
537 map.insert(
538 ::jacquard_common::smol_str::SmolStr::new_static(
539 "displayName",
540 ),
541 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
542 description: None,
543 format: None,
544 default: None,
545 min_length: None,
546 max_length: None,
547 min_graphemes: None,
548 max_graphemes: None,
549 r#enum: None,
550 r#const: None,
551 known_values: None,
552 }),
553 );
554 map.insert(
555 ::jacquard_common::smol_str::SmolStr::new_static(
556 "indexedAt",
557 ),
558 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
559 description: None,
560 format: Some(
561 ::jacquard_lexicon::lexicon::LexStringFormat::Datetime,
562 ),
563 default: None,
564 min_length: None,
565 max_length: None,
566 min_graphemes: None,
567 max_graphemes: None,
568 r#enum: None,
569 r#const: None,
570 known_values: None,
571 }),
572 );
573 map.insert(
574 ::jacquard_common::smol_str::SmolStr::new_static("labels"),
575 ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
576 description: None,
577 items: ::jacquard_lexicon::lexicon::LexArrayItem::Ref(::jacquard_lexicon::lexicon::LexRef {
578 description: None,
579 r#ref: ::jacquard_common::CowStr::new_static(
580 "com.atproto.label.defs#label",
581 ),
582 }),
583 min_length: None,
584 max_length: None,
585 }),
586 );
587 map.insert(
588 ::jacquard_common::smol_str::SmolStr::new_static(
589 "likeCount",
590 ),
591 ::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger {
592 description: None,
593 default: None,
594 minimum: Some(0i64),
595 maximum: None,
596 r#enum: None,
597 r#const: None,
598 }),
599 );
600 map.insert(
601 ::jacquard_common::smol_str::SmolStr::new_static("uri"),
602 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
603 description: None,
604 format: Some(
605 ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
606 ),
607 default: None,
608 min_length: None,
609 max_length: None,
610 min_graphemes: None,
611 max_graphemes: None,
612 r#enum: None,
613 r#const: None,
614 known_values: None,
615 }),
616 );
617 map.insert(
618 ::jacquard_common::smol_str::SmolStr::new_static("viewer"),
619 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
620 description: None,
621 r#ref: ::jacquard_common::CowStr::new_static(
622 "#generatorViewerState",
623 ),
624 }),
625 );
626 map
627 },
628 }),
629 );
630 map.insert(
631 ::jacquard_common::smol_str::SmolStr::new_static("generatorViewerState"),
632 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
633 description: None,
634 required: None,
635 nullable: None,
636 properties: {
637 #[allow(unused_mut)]
638 let mut map = ::std::collections::BTreeMap::new();
639 map.insert(
640 ::jacquard_common::smol_str::SmolStr::new_static("like"),
641 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
642 description: None,
643 format: Some(
644 ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
645 ),
646 default: None,
647 min_length: None,
648 max_length: None,
649 min_graphemes: None,
650 max_graphemes: None,
651 r#enum: None,
652 r#const: None,
653 known_values: None,
654 }),
655 );
656 map
657 },
658 }),
659 );
660 map.insert(
661 ::jacquard_common::smol_str::SmolStr::new_static("interaction"),
662 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
663 description: None,
664 required: None,
665 nullable: None,
666 properties: {
667 #[allow(unused_mut)]
668 let mut map = ::std::collections::BTreeMap::new();
669 map.insert(
670 ::jacquard_common::smol_str::SmolStr::new_static("event"),
671 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
672 description: None,
673 format: None,
674 default: None,
675 min_length: None,
676 max_length: None,
677 min_graphemes: None,
678 max_graphemes: None,
679 r#enum: None,
680 r#const: None,
681 known_values: None,
682 }),
683 );
684 map.insert(
685 ::jacquard_common::smol_str::SmolStr::new_static(
686 "feedContext",
687 ),
688 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
689 description: Some(
690 ::jacquard_common::CowStr::new_static(
691 "Context on a feed item that was originally supplied by the feed generator on getFeedSkeleton.",
692 ),
693 ),
694 format: None,
695 default: None,
696 min_length: None,
697 max_length: Some(2000usize),
698 min_graphemes: None,
699 max_graphemes: None,
700 r#enum: None,
701 r#const: None,
702 known_values: None,
703 }),
704 );
705 map.insert(
706 ::jacquard_common::smol_str::SmolStr::new_static("item"),
707 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
708 description: None,
709 format: Some(
710 ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
711 ),
712 default: None,
713 min_length: None,
714 max_length: None,
715 min_graphemes: None,
716 max_graphemes: None,
717 r#enum: None,
718 r#const: None,
719 known_values: None,
720 }),
721 );
722 map.insert(
723 ::jacquard_common::smol_str::SmolStr::new_static("reqId"),
724 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
725 description: Some(
726 ::jacquard_common::CowStr::new_static(
727 "Unique identifier per request that may be passed back alongside interactions.",
728 ),
729 ),
730 format: None,
731 default: None,
732 min_length: None,
733 max_length: Some(100usize),
734 min_graphemes: None,
735 max_graphemes: None,
736 r#enum: None,
737 r#const: None,
738 known_values: None,
739 }),
740 );
741 map
742 },
743 }),
744 );
745 map.insert(
746 ::jacquard_common::smol_str::SmolStr::new_static("interactionLike"),
747 ::jacquard_lexicon::lexicon::LexUserType::Token(::jacquard_lexicon::lexicon::LexToken {
748 description: None,
749 }),
750 );
751 map.insert(
752 ::jacquard_common::smol_str::SmolStr::new_static("interactionQuote"),
753 ::jacquard_lexicon::lexicon::LexUserType::Token(::jacquard_lexicon::lexicon::LexToken {
754 description: None,
755 }),
756 );
757 map.insert(
758 ::jacquard_common::smol_str::SmolStr::new_static("interactionReply"),
759 ::jacquard_lexicon::lexicon::LexUserType::Token(::jacquard_lexicon::lexicon::LexToken {
760 description: None,
761 }),
762 );
763 map.insert(
764 ::jacquard_common::smol_str::SmolStr::new_static("interactionRepost"),
765 ::jacquard_lexicon::lexicon::LexUserType::Token(::jacquard_lexicon::lexicon::LexToken {
766 description: None,
767 }),
768 );
769 map.insert(
770 ::jacquard_common::smol_str::SmolStr::new_static("interactionSeen"),
771 ::jacquard_lexicon::lexicon::LexUserType::Token(::jacquard_lexicon::lexicon::LexToken {
772 description: None,
773 }),
774 );
775 map.insert(
776 ::jacquard_common::smol_str::SmolStr::new_static("interactionShare"),
777 ::jacquard_lexicon::lexicon::LexUserType::Token(::jacquard_lexicon::lexicon::LexToken {
778 description: None,
779 }),
780 );
781 map.insert(
782 ::jacquard_common::smol_str::SmolStr::new_static("notFoundPost"),
783 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
784 description: None,
785 required: Some(
786 vec![
787 ::jacquard_common::smol_str::SmolStr::new_static("uri"),
788 ::jacquard_common::smol_str::SmolStr::new_static("notFound")
789 ],
790 ),
791 nullable: None,
792 properties: {
793 #[allow(unused_mut)]
794 let mut map = ::std::collections::BTreeMap::new();
795 map.insert(
796 ::jacquard_common::smol_str::SmolStr::new_static("notFound"),
797 ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
798 description: None,
799 default: None,
800 r#const: None,
801 }),
802 );
803 map.insert(
804 ::jacquard_common::smol_str::SmolStr::new_static("uri"),
805 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
806 description: None,
807 format: Some(
808 ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
809 ),
810 default: None,
811 min_length: None,
812 max_length: None,
813 min_graphemes: None,
814 max_graphemes: None,
815 r#enum: None,
816 r#const: None,
817 known_values: None,
818 }),
819 );
820 map
821 },
822 }),
823 );
824 map.insert(
825 ::jacquard_common::smol_str::SmolStr::new_static("postView"),
826 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
827 description: None,
828 required: Some(
829 vec![
830 ::jacquard_common::smol_str::SmolStr::new_static("uri"),
831 ::jacquard_common::smol_str::SmolStr::new_static("cid"),
832 ::jacquard_common::smol_str::SmolStr::new_static("author"),
833 ::jacquard_common::smol_str::SmolStr::new_static("record"),
834 ::jacquard_common::smol_str::SmolStr::new_static("indexedAt")
835 ],
836 ),
837 nullable: None,
838 properties: {
839 #[allow(unused_mut)]
840 let mut map = ::std::collections::BTreeMap::new();
841 map.insert(
842 ::jacquard_common::smol_str::SmolStr::new_static("author"),
843 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
844 description: None,
845 r#ref: ::jacquard_common::CowStr::new_static(
846 "app.bsky.actor.defs#profileViewBasic",
847 ),
848 }),
849 );
850 map.insert(
851 ::jacquard_common::smol_str::SmolStr::new_static(
852 "bookmarkCount",
853 ),
854 ::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger {
855 description: None,
856 default: None,
857 minimum: None,
858 maximum: None,
859 r#enum: None,
860 r#const: None,
861 }),
862 );
863 map.insert(
864 ::jacquard_common::smol_str::SmolStr::new_static("cid"),
865 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
866 description: None,
867 format: Some(
868 ::jacquard_lexicon::lexicon::LexStringFormat::Cid,
869 ),
870 default: None,
871 min_length: None,
872 max_length: None,
873 min_graphemes: None,
874 max_graphemes: None,
875 r#enum: None,
876 r#const: None,
877 known_values: None,
878 }),
879 );
880 map.insert(
881 ::jacquard_common::smol_str::SmolStr::new_static("debug"),
882 ::jacquard_lexicon::lexicon::LexObjectProperty::Unknown(::jacquard_lexicon::lexicon::LexUnknown {
883 description: None,
884 }),
885 );
886 map.insert(
887 ::jacquard_common::smol_str::SmolStr::new_static("embed"),
888 ::jacquard_lexicon::lexicon::LexObjectProperty::Union(::jacquard_lexicon::lexicon::LexRefUnion {
889 description: None,
890 refs: vec![
891 ::jacquard_common::CowStr::new_static("app.bsky.embed.images#view"),
892 ::jacquard_common::CowStr::new_static("app.bsky.embed.video#view"),
893 ::jacquard_common::CowStr::new_static("app.bsky.embed.external#view"),
894 ::jacquard_common::CowStr::new_static("app.bsky.embed.record#view"),
895 ::jacquard_common::CowStr::new_static("app.bsky.embed.recordWithMedia#view")
896 ],
897 closed: None,
898 }),
899 );
900 map.insert(
901 ::jacquard_common::smol_str::SmolStr::new_static(
902 "indexedAt",
903 ),
904 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
905 description: None,
906 format: Some(
907 ::jacquard_lexicon::lexicon::LexStringFormat::Datetime,
908 ),
909 default: None,
910 min_length: None,
911 max_length: None,
912 min_graphemes: None,
913 max_graphemes: None,
914 r#enum: None,
915 r#const: None,
916 known_values: None,
917 }),
918 );
919 map.insert(
920 ::jacquard_common::smol_str::SmolStr::new_static("labels"),
921 ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
922 description: None,
923 items: ::jacquard_lexicon::lexicon::LexArrayItem::Ref(::jacquard_lexicon::lexicon::LexRef {
924 description: None,
925 r#ref: ::jacquard_common::CowStr::new_static(
926 "com.atproto.label.defs#label",
927 ),
928 }),
929 min_length: None,
930 max_length: None,
931 }),
932 );
933 map.insert(
934 ::jacquard_common::smol_str::SmolStr::new_static(
935 "likeCount",
936 ),
937 ::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger {
938 description: None,
939 default: None,
940 minimum: None,
941 maximum: None,
942 r#enum: None,
943 r#const: None,
944 }),
945 );
946 map.insert(
947 ::jacquard_common::smol_str::SmolStr::new_static(
948 "quoteCount",
949 ),
950 ::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger {
951 description: None,
952 default: None,
953 minimum: None,
954 maximum: None,
955 r#enum: None,
956 r#const: None,
957 }),
958 );
959 map.insert(
960 ::jacquard_common::smol_str::SmolStr::new_static("record"),
961 ::jacquard_lexicon::lexicon::LexObjectProperty::Unknown(::jacquard_lexicon::lexicon::LexUnknown {
962 description: None,
963 }),
964 );
965 map.insert(
966 ::jacquard_common::smol_str::SmolStr::new_static(
967 "replyCount",
968 ),
969 ::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger {
970 description: None,
971 default: None,
972 minimum: None,
973 maximum: None,
974 r#enum: None,
975 r#const: None,
976 }),
977 );
978 map.insert(
979 ::jacquard_common::smol_str::SmolStr::new_static(
980 "repostCount",
981 ),
982 ::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger {
983 description: None,
984 default: None,
985 minimum: None,
986 maximum: None,
987 r#enum: None,
988 r#const: None,
989 }),
990 );
991 map.insert(
992 ::jacquard_common::smol_str::SmolStr::new_static(
993 "threadgate",
994 ),
995 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
996 description: None,
997 r#ref: ::jacquard_common::CowStr::new_static(
998 "#threadgateView",
999 ),
1000 }),
1001 );
1002 map.insert(
1003 ::jacquard_common::smol_str::SmolStr::new_static("uri"),
1004 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1005 description: None,
1006 format: Some(
1007 ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
1008 ),
1009 default: None,
1010 min_length: None,
1011 max_length: None,
1012 min_graphemes: None,
1013 max_graphemes: None,
1014 r#enum: None,
1015 r#const: None,
1016 known_values: None,
1017 }),
1018 );
1019 map.insert(
1020 ::jacquard_common::smol_str::SmolStr::new_static("viewer"),
1021 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
1022 description: None,
1023 r#ref: ::jacquard_common::CowStr::new_static("#viewerState"),
1024 }),
1025 );
1026 map
1027 },
1028 }),
1029 );
1030 map.insert(
1031 ::jacquard_common::smol_str::SmolStr::new_static("reasonPin"),
1032 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
1033 description: None,
1034 required: None,
1035 nullable: None,
1036 properties: {
1037 #[allow(unused_mut)]
1038 let mut map = ::std::collections::BTreeMap::new();
1039 map
1040 },
1041 }),
1042 );
1043 map.insert(
1044 ::jacquard_common::smol_str::SmolStr::new_static("reasonRepost"),
1045 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
1046 description: None,
1047 required: Some(
1048 vec![
1049 ::jacquard_common::smol_str::SmolStr::new_static("by"),
1050 ::jacquard_common::smol_str::SmolStr::new_static("indexedAt")
1051 ],
1052 ),
1053 nullable: None,
1054 properties: {
1055 #[allow(unused_mut)]
1056 let mut map = ::std::collections::BTreeMap::new();
1057 map.insert(
1058 ::jacquard_common::smol_str::SmolStr::new_static("by"),
1059 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
1060 description: None,
1061 r#ref: ::jacquard_common::CowStr::new_static(
1062 "app.bsky.actor.defs#profileViewBasic",
1063 ),
1064 }),
1065 );
1066 map.insert(
1067 ::jacquard_common::smol_str::SmolStr::new_static("cid"),
1068 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1069 description: None,
1070 format: Some(
1071 ::jacquard_lexicon::lexicon::LexStringFormat::Cid,
1072 ),
1073 default: None,
1074 min_length: None,
1075 max_length: None,
1076 min_graphemes: None,
1077 max_graphemes: None,
1078 r#enum: None,
1079 r#const: None,
1080 known_values: None,
1081 }),
1082 );
1083 map.insert(
1084 ::jacquard_common::smol_str::SmolStr::new_static(
1085 "indexedAt",
1086 ),
1087 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1088 description: None,
1089 format: Some(
1090 ::jacquard_lexicon::lexicon::LexStringFormat::Datetime,
1091 ),
1092 default: None,
1093 min_length: None,
1094 max_length: None,
1095 min_graphemes: None,
1096 max_graphemes: None,
1097 r#enum: None,
1098 r#const: None,
1099 known_values: None,
1100 }),
1101 );
1102 map.insert(
1103 ::jacquard_common::smol_str::SmolStr::new_static("uri"),
1104 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1105 description: None,
1106 format: Some(
1107 ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
1108 ),
1109 default: None,
1110 min_length: None,
1111 max_length: None,
1112 min_graphemes: None,
1113 max_graphemes: None,
1114 r#enum: None,
1115 r#const: None,
1116 known_values: None,
1117 }),
1118 );
1119 map
1120 },
1121 }),
1122 );
1123 map.insert(
1124 ::jacquard_common::smol_str::SmolStr::new_static("replyRef"),
1125 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
1126 description: None,
1127 required: Some(
1128 vec![
1129 ::jacquard_common::smol_str::SmolStr::new_static("root"),
1130 ::jacquard_common::smol_str::SmolStr::new_static("parent")
1131 ],
1132 ),
1133 nullable: None,
1134 properties: {
1135 #[allow(unused_mut)]
1136 let mut map = ::std::collections::BTreeMap::new();
1137 map.insert(
1138 ::jacquard_common::smol_str::SmolStr::new_static(
1139 "grandparentAuthor",
1140 ),
1141 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
1142 description: None,
1143 r#ref: ::jacquard_common::CowStr::new_static(
1144 "app.bsky.actor.defs#profileViewBasic",
1145 ),
1146 }),
1147 );
1148 map.insert(
1149 ::jacquard_common::smol_str::SmolStr::new_static("parent"),
1150 ::jacquard_lexicon::lexicon::LexObjectProperty::Union(::jacquard_lexicon::lexicon::LexRefUnion {
1151 description: None,
1152 refs: vec![
1153 ::jacquard_common::CowStr::new_static("#postView"),
1154 ::jacquard_common::CowStr::new_static("#notFoundPost"),
1155 ::jacquard_common::CowStr::new_static("#blockedPost")
1156 ],
1157 closed: None,
1158 }),
1159 );
1160 map.insert(
1161 ::jacquard_common::smol_str::SmolStr::new_static("root"),
1162 ::jacquard_lexicon::lexicon::LexObjectProperty::Union(::jacquard_lexicon::lexicon::LexRefUnion {
1163 description: None,
1164 refs: vec![
1165 ::jacquard_common::CowStr::new_static("#postView"),
1166 ::jacquard_common::CowStr::new_static("#notFoundPost"),
1167 ::jacquard_common::CowStr::new_static("#blockedPost")
1168 ],
1169 closed: None,
1170 }),
1171 );
1172 map
1173 },
1174 }),
1175 );
1176 map.insert(
1177 ::jacquard_common::smol_str::SmolStr::new_static("requestLess"),
1178 ::jacquard_lexicon::lexicon::LexUserType::Token(::jacquard_lexicon::lexicon::LexToken {
1179 description: None,
1180 }),
1181 );
1182 map.insert(
1183 ::jacquard_common::smol_str::SmolStr::new_static("requestMore"),
1184 ::jacquard_lexicon::lexicon::LexUserType::Token(::jacquard_lexicon::lexicon::LexToken {
1185 description: None,
1186 }),
1187 );
1188 map.insert(
1189 ::jacquard_common::smol_str::SmolStr::new_static("skeletonFeedPost"),
1190 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
1191 description: None,
1192 required: Some(
1193 vec![::jacquard_common::smol_str::SmolStr::new_static("post")],
1194 ),
1195 nullable: None,
1196 properties: {
1197 #[allow(unused_mut)]
1198 let mut map = ::std::collections::BTreeMap::new();
1199 map.insert(
1200 ::jacquard_common::smol_str::SmolStr::new_static(
1201 "feedContext",
1202 ),
1203 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1204 description: Some(
1205 ::jacquard_common::CowStr::new_static(
1206 "Context that will be passed through to client and may be passed to feed generator back alongside interactions.",
1207 ),
1208 ),
1209 format: None,
1210 default: None,
1211 min_length: None,
1212 max_length: Some(2000usize),
1213 min_graphemes: None,
1214 max_graphemes: None,
1215 r#enum: None,
1216 r#const: None,
1217 known_values: None,
1218 }),
1219 );
1220 map.insert(
1221 ::jacquard_common::smol_str::SmolStr::new_static("post"),
1222 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1223 description: None,
1224 format: Some(
1225 ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
1226 ),
1227 default: None,
1228 min_length: None,
1229 max_length: None,
1230 min_graphemes: None,
1231 max_graphemes: None,
1232 r#enum: None,
1233 r#const: None,
1234 known_values: None,
1235 }),
1236 );
1237 map.insert(
1238 ::jacquard_common::smol_str::SmolStr::new_static("reason"),
1239 ::jacquard_lexicon::lexicon::LexObjectProperty::Union(::jacquard_lexicon::lexicon::LexRefUnion {
1240 description: None,
1241 refs: vec![
1242 ::jacquard_common::CowStr::new_static("#skeletonReasonRepost"),
1243 ::jacquard_common::CowStr::new_static("#skeletonReasonPin")
1244 ],
1245 closed: None,
1246 }),
1247 );
1248 map
1249 },
1250 }),
1251 );
1252 map.insert(
1253 ::jacquard_common::smol_str::SmolStr::new_static("skeletonReasonPin"),
1254 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
1255 description: None,
1256 required: None,
1257 nullable: None,
1258 properties: {
1259 #[allow(unused_mut)]
1260 let mut map = ::std::collections::BTreeMap::new();
1261 map
1262 },
1263 }),
1264 );
1265 map.insert(
1266 ::jacquard_common::smol_str::SmolStr::new_static("skeletonReasonRepost"),
1267 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
1268 description: None,
1269 required: Some(
1270 vec![::jacquard_common::smol_str::SmolStr::new_static("repost")],
1271 ),
1272 nullable: None,
1273 properties: {
1274 #[allow(unused_mut)]
1275 let mut map = ::std::collections::BTreeMap::new();
1276 map.insert(
1277 ::jacquard_common::smol_str::SmolStr::new_static("repost"),
1278 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1279 description: None,
1280 format: Some(
1281 ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
1282 ),
1283 default: None,
1284 min_length: None,
1285 max_length: None,
1286 min_graphemes: None,
1287 max_graphemes: None,
1288 r#enum: None,
1289 r#const: None,
1290 known_values: None,
1291 }),
1292 );
1293 map
1294 },
1295 }),
1296 );
1297 map.insert(
1298 ::jacquard_common::smol_str::SmolStr::new_static("threadContext"),
1299 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
1300 description: Some(
1301 ::jacquard_common::CowStr::new_static(
1302 "Metadata about this post within the context of the thread it is in.",
1303 ),
1304 ),
1305 required: None,
1306 nullable: None,
1307 properties: {
1308 #[allow(unused_mut)]
1309 let mut map = ::std::collections::BTreeMap::new();
1310 map.insert(
1311 ::jacquard_common::smol_str::SmolStr::new_static(
1312 "rootAuthorLike",
1313 ),
1314 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1315 description: None,
1316 format: Some(
1317 ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
1318 ),
1319 default: None,
1320 min_length: None,
1321 max_length: None,
1322 min_graphemes: None,
1323 max_graphemes: None,
1324 r#enum: None,
1325 r#const: None,
1326 known_values: None,
1327 }),
1328 );
1329 map
1330 },
1331 }),
1332 );
1333 map.insert(
1334 ::jacquard_common::smol_str::SmolStr::new_static("threadViewPost"),
1335 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
1336 description: None,
1337 required: Some(
1338 vec![::jacquard_common::smol_str::SmolStr::new_static("post")],
1339 ),
1340 nullable: None,
1341 properties: {
1342 #[allow(unused_mut)]
1343 let mut map = ::std::collections::BTreeMap::new();
1344 map.insert(
1345 ::jacquard_common::smol_str::SmolStr::new_static("parent"),
1346 ::jacquard_lexicon::lexicon::LexObjectProperty::Union(::jacquard_lexicon::lexicon::LexRefUnion {
1347 description: None,
1348 refs: vec![
1349 ::jacquard_common::CowStr::new_static("#threadViewPost"),
1350 ::jacquard_common::CowStr::new_static("#notFoundPost"),
1351 ::jacquard_common::CowStr::new_static("#blockedPost")
1352 ],
1353 closed: None,
1354 }),
1355 );
1356 map.insert(
1357 ::jacquard_common::smol_str::SmolStr::new_static("post"),
1358 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
1359 description: None,
1360 r#ref: ::jacquard_common::CowStr::new_static("#postView"),
1361 }),
1362 );
1363 map.insert(
1364 ::jacquard_common::smol_str::SmolStr::new_static("replies"),
1365 ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
1366 description: None,
1367 items: ::jacquard_lexicon::lexicon::LexArrayItem::Union(::jacquard_lexicon::lexicon::LexRefUnion {
1368 description: None,
1369 refs: vec![
1370 ::jacquard_common::CowStr::new_static("#threadViewPost"),
1371 ::jacquard_common::CowStr::new_static("#notFoundPost"),
1372 ::jacquard_common::CowStr::new_static("#blockedPost")
1373 ],
1374 closed: None,
1375 }),
1376 min_length: None,
1377 max_length: None,
1378 }),
1379 );
1380 map.insert(
1381 ::jacquard_common::smol_str::SmolStr::new_static(
1382 "threadContext",
1383 ),
1384 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
1385 description: None,
1386 r#ref: ::jacquard_common::CowStr::new_static(
1387 "#threadContext",
1388 ),
1389 }),
1390 );
1391 map
1392 },
1393 }),
1394 );
1395 map.insert(
1396 ::jacquard_common::smol_str::SmolStr::new_static("threadgateView"),
1397 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
1398 description: None,
1399 required: None,
1400 nullable: None,
1401 properties: {
1402 #[allow(unused_mut)]
1403 let mut map = ::std::collections::BTreeMap::new();
1404 map.insert(
1405 ::jacquard_common::smol_str::SmolStr::new_static("cid"),
1406 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1407 description: None,
1408 format: Some(
1409 ::jacquard_lexicon::lexicon::LexStringFormat::Cid,
1410 ),
1411 default: None,
1412 min_length: None,
1413 max_length: None,
1414 min_graphemes: None,
1415 max_graphemes: None,
1416 r#enum: None,
1417 r#const: None,
1418 known_values: None,
1419 }),
1420 );
1421 map.insert(
1422 ::jacquard_common::smol_str::SmolStr::new_static("lists"),
1423 ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
1424 description: None,
1425 items: ::jacquard_lexicon::lexicon::LexArrayItem::Ref(::jacquard_lexicon::lexicon::LexRef {
1426 description: None,
1427 r#ref: ::jacquard_common::CowStr::new_static(
1428 "app.bsky.graph.defs#listViewBasic",
1429 ),
1430 }),
1431 min_length: None,
1432 max_length: None,
1433 }),
1434 );
1435 map.insert(
1436 ::jacquard_common::smol_str::SmolStr::new_static("record"),
1437 ::jacquard_lexicon::lexicon::LexObjectProperty::Unknown(::jacquard_lexicon::lexicon::LexUnknown {
1438 description: None,
1439 }),
1440 );
1441 map.insert(
1442 ::jacquard_common::smol_str::SmolStr::new_static("uri"),
1443 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1444 description: None,
1445 format: Some(
1446 ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
1447 ),
1448 default: None,
1449 min_length: None,
1450 max_length: None,
1451 min_graphemes: None,
1452 max_graphemes: None,
1453 r#enum: None,
1454 r#const: None,
1455 known_values: None,
1456 }),
1457 );
1458 map
1459 },
1460 }),
1461 );
1462 map.insert(
1463 ::jacquard_common::smol_str::SmolStr::new_static("viewerState"),
1464 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
1465 description: Some(
1466 ::jacquard_common::CowStr::new_static(
1467 "Metadata about the requesting account's relationship with the subject content. Only has meaningful content for authed requests.",
1468 ),
1469 ),
1470 required: None,
1471 nullable: None,
1472 properties: {
1473 #[allow(unused_mut)]
1474 let mut map = ::std::collections::BTreeMap::new();
1475 map.insert(
1476 ::jacquard_common::smol_str::SmolStr::new_static(
1477 "bookmarked",
1478 ),
1479 ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
1480 description: None,
1481 default: None,
1482 r#const: None,
1483 }),
1484 );
1485 map.insert(
1486 ::jacquard_common::smol_str::SmolStr::new_static(
1487 "embeddingDisabled",
1488 ),
1489 ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
1490 description: None,
1491 default: None,
1492 r#const: None,
1493 }),
1494 );
1495 map.insert(
1496 ::jacquard_common::smol_str::SmolStr::new_static("like"),
1497 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1498 description: None,
1499 format: Some(
1500 ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
1501 ),
1502 default: None,
1503 min_length: None,
1504 max_length: None,
1505 min_graphemes: None,
1506 max_graphemes: None,
1507 r#enum: None,
1508 r#const: None,
1509 known_values: None,
1510 }),
1511 );
1512 map.insert(
1513 ::jacquard_common::smol_str::SmolStr::new_static("pinned"),
1514 ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
1515 description: None,
1516 default: None,
1517 r#const: None,
1518 }),
1519 );
1520 map.insert(
1521 ::jacquard_common::smol_str::SmolStr::new_static(
1522 "replyDisabled",
1523 ),
1524 ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
1525 description: None,
1526 default: None,
1527 r#const: None,
1528 }),
1529 );
1530 map.insert(
1531 ::jacquard_common::smol_str::SmolStr::new_static("repost"),
1532 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1533 description: None,
1534 format: Some(
1535 ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
1536 ),
1537 default: None,
1538 min_length: None,
1539 max_length: None,
1540 min_graphemes: None,
1541 max_graphemes: None,
1542 r#enum: None,
1543 r#const: None,
1544 known_values: None,
1545 }),
1546 );
1547 map.insert(
1548 ::jacquard_common::smol_str::SmolStr::new_static(
1549 "threadMuted",
1550 ),
1551 ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
1552 description: None,
1553 default: None,
1554 r#const: None,
1555 }),
1556 );
1557 map
1558 },
1559 }),
1560 );
1561 map
1562 },
1563 }
1564}
1565
1566impl<'a> ::jacquard_lexicon::schema::LexiconSchema for BlockedAuthor<'a> {
1567 fn nsid() -> &'static str {
1568 "app.bsky.feed.defs"
1569 }
1570 fn def_name() -> &'static str {
1571 "blockedAuthor"
1572 }
1573 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
1574 lexicon_doc_app_bsky_feed_defs()
1575 }
1576 fn validate(
1577 &self,
1578 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
1579 Ok(())
1580 }
1581}
1582
1583#[jacquard_derive::lexicon]
1584#[derive(
1585 serde::Serialize,
1586 serde::Deserialize,
1587 Debug,
1588 Clone,
1589 PartialEq,
1590 Eq,
1591 jacquard_derive::IntoStatic
1592)]
1593#[serde(rename_all = "camelCase")]
1594pub struct BlockedPost<'a> {
1595 #[serde(borrow)]
1596 pub author: crate::app_bsky::feed::BlockedAuthor<'a>,
1597 pub blocked: bool,
1598 #[serde(borrow)]
1599 pub uri: jacquard_common::types::string::AtUri<'a>,
1600}
1601
1602pub mod blocked_post_state {
1603
1604 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
1605 #[allow(unused)]
1606 use ::core::marker::PhantomData;
1607 mod sealed {
1608 pub trait Sealed {}
1609 }
1610 pub trait State: sealed::Sealed {
1612 type Uri;
1613 type Blocked;
1614 type Author;
1615 }
1616 pub struct Empty(());
1618 impl sealed::Sealed for Empty {}
1619 impl State for Empty {
1620 type Uri = Unset;
1621 type Blocked = Unset;
1622 type Author = Unset;
1623 }
1624 pub struct SetUri<S: State = Empty>(PhantomData<fn() -> S>);
1626 impl<S: State> sealed::Sealed for SetUri<S> {}
1627 impl<S: State> State for SetUri<S> {
1628 type Uri = Set<members::uri>;
1629 type Blocked = S::Blocked;
1630 type Author = S::Author;
1631 }
1632 pub struct SetBlocked<S: State = Empty>(PhantomData<fn() -> S>);
1634 impl<S: State> sealed::Sealed for SetBlocked<S> {}
1635 impl<S: State> State for SetBlocked<S> {
1636 type Uri = S::Uri;
1637 type Blocked = Set<members::blocked>;
1638 type Author = S::Author;
1639 }
1640 pub struct SetAuthor<S: State = Empty>(PhantomData<fn() -> S>);
1642 impl<S: State> sealed::Sealed for SetAuthor<S> {}
1643 impl<S: State> State for SetAuthor<S> {
1644 type Uri = S::Uri;
1645 type Blocked = S::Blocked;
1646 type Author = Set<members::author>;
1647 }
1648 #[allow(non_camel_case_types)]
1650 pub mod members {
1651 pub struct uri(());
1653 pub struct blocked(());
1655 pub struct author(());
1657 }
1658}
1659
1660pub struct BlockedPostBuilder<'a, S: blocked_post_state::State> {
1662 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
1663 __unsafe_private_named: (
1664 ::core::option::Option<crate::app_bsky::feed::BlockedAuthor<'a>>,
1665 ::core::option::Option<bool>,
1666 ::core::option::Option<jacquard_common::types::string::AtUri<'a>>,
1667 ),
1668 _phantom: ::core::marker::PhantomData<&'a ()>,
1669}
1670
1671impl<'a> BlockedPost<'a> {
1672 pub fn new() -> BlockedPostBuilder<'a, blocked_post_state::Empty> {
1674 BlockedPostBuilder::new()
1675 }
1676}
1677
1678impl<'a> BlockedPostBuilder<'a, blocked_post_state::Empty> {
1679 pub fn new() -> Self {
1681 BlockedPostBuilder {
1682 _phantom_state: ::core::marker::PhantomData,
1683 __unsafe_private_named: (None, None, None),
1684 _phantom: ::core::marker::PhantomData,
1685 }
1686 }
1687}
1688
1689impl<'a, S> BlockedPostBuilder<'a, S>
1690where
1691 S: blocked_post_state::State,
1692 S::Author: blocked_post_state::IsUnset,
1693{
1694 pub fn author(
1696 mut self,
1697 value: impl Into<crate::app_bsky::feed::BlockedAuthor<'a>>,
1698 ) -> BlockedPostBuilder<'a, blocked_post_state::SetAuthor<S>> {
1699 self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
1700 BlockedPostBuilder {
1701 _phantom_state: ::core::marker::PhantomData,
1702 __unsafe_private_named: self.__unsafe_private_named,
1703 _phantom: ::core::marker::PhantomData,
1704 }
1705 }
1706}
1707
1708impl<'a, S> BlockedPostBuilder<'a, S>
1709where
1710 S: blocked_post_state::State,
1711 S::Blocked: blocked_post_state::IsUnset,
1712{
1713 pub fn blocked(
1715 mut self,
1716 value: impl Into<bool>,
1717 ) -> BlockedPostBuilder<'a, blocked_post_state::SetBlocked<S>> {
1718 self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
1719 BlockedPostBuilder {
1720 _phantom_state: ::core::marker::PhantomData,
1721 __unsafe_private_named: self.__unsafe_private_named,
1722 _phantom: ::core::marker::PhantomData,
1723 }
1724 }
1725}
1726
1727impl<'a, S> BlockedPostBuilder<'a, S>
1728where
1729 S: blocked_post_state::State,
1730 S::Uri: blocked_post_state::IsUnset,
1731{
1732 pub fn uri(
1734 mut self,
1735 value: impl Into<jacquard_common::types::string::AtUri<'a>>,
1736 ) -> BlockedPostBuilder<'a, blocked_post_state::SetUri<S>> {
1737 self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into());
1738 BlockedPostBuilder {
1739 _phantom_state: ::core::marker::PhantomData,
1740 __unsafe_private_named: self.__unsafe_private_named,
1741 _phantom: ::core::marker::PhantomData,
1742 }
1743 }
1744}
1745
1746impl<'a, S> BlockedPostBuilder<'a, S>
1747where
1748 S: blocked_post_state::State,
1749 S::Uri: blocked_post_state::IsSet,
1750 S::Blocked: blocked_post_state::IsSet,
1751 S::Author: blocked_post_state::IsSet,
1752{
1753 pub fn build(self) -> BlockedPost<'a> {
1755 BlockedPost {
1756 author: self.__unsafe_private_named.0.unwrap(),
1757 blocked: self.__unsafe_private_named.1.unwrap(),
1758 uri: self.__unsafe_private_named.2.unwrap(),
1759 extra_data: Default::default(),
1760 }
1761 }
1762 pub fn build_with_data(
1764 self,
1765 extra_data: std::collections::BTreeMap<
1766 jacquard_common::smol_str::SmolStr,
1767 jacquard_common::types::value::Data<'a>,
1768 >,
1769 ) -> BlockedPost<'a> {
1770 BlockedPost {
1771 author: self.__unsafe_private_named.0.unwrap(),
1772 blocked: self.__unsafe_private_named.1.unwrap(),
1773 uri: self.__unsafe_private_named.2.unwrap(),
1774 extra_data: Some(extra_data),
1775 }
1776 }
1777}
1778
1779impl<'a> ::jacquard_lexicon::schema::LexiconSchema for BlockedPost<'a> {
1780 fn nsid() -> &'static str {
1781 "app.bsky.feed.defs"
1782 }
1783 fn def_name() -> &'static str {
1784 "blockedPost"
1785 }
1786 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
1787 lexicon_doc_app_bsky_feed_defs()
1788 }
1789 fn validate(
1790 &self,
1791 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
1792 Ok(())
1793 }
1794}
1795
1796#[derive(
1798 serde::Serialize,
1799 serde::Deserialize,
1800 Debug,
1801 Clone,
1802 PartialEq,
1803 Eq,
1804 Hash,
1805 jacquard_derive::IntoStatic
1806)]
1807pub struct ClickthroughAuthor;
1808impl std::fmt::Display for ClickthroughAuthor {
1809 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1810 write!(f, "clickthroughAuthor")
1811 }
1812}
1813
1814#[derive(
1816 serde::Serialize,
1817 serde::Deserialize,
1818 Debug,
1819 Clone,
1820 PartialEq,
1821 Eq,
1822 Hash,
1823 jacquard_derive::IntoStatic
1824)]
1825pub struct ClickthroughEmbed;
1826impl std::fmt::Display for ClickthroughEmbed {
1827 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1828 write!(f, "clickthroughEmbed")
1829 }
1830}
1831
1832#[derive(
1834 serde::Serialize,
1835 serde::Deserialize,
1836 Debug,
1837 Clone,
1838 PartialEq,
1839 Eq,
1840 Hash,
1841 jacquard_derive::IntoStatic
1842)]
1843pub struct ClickthroughItem;
1844impl std::fmt::Display for ClickthroughItem {
1845 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1846 write!(f, "clickthroughItem")
1847 }
1848}
1849
1850#[derive(
1852 serde::Serialize,
1853 serde::Deserialize,
1854 Debug,
1855 Clone,
1856 PartialEq,
1857 Eq,
1858 Hash,
1859 jacquard_derive::IntoStatic
1860)]
1861pub struct ClickthroughReposter;
1862impl std::fmt::Display for ClickthroughReposter {
1863 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1864 write!(f, "clickthroughReposter")
1865 }
1866}
1867
1868#[derive(
1870 serde::Serialize,
1871 serde::Deserialize,
1872 Debug,
1873 Clone,
1874 PartialEq,
1875 Eq,
1876 Hash,
1877 jacquard_derive::IntoStatic
1878)]
1879pub struct ContentModeUnspecified;
1880impl std::fmt::Display for ContentModeUnspecified {
1881 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1882 write!(f, "contentModeUnspecified")
1883 }
1884}
1885
1886#[derive(
1888 serde::Serialize,
1889 serde::Deserialize,
1890 Debug,
1891 Clone,
1892 PartialEq,
1893 Eq,
1894 Hash,
1895 jacquard_derive::IntoStatic
1896)]
1897pub struct ContentModeVideo;
1898impl std::fmt::Display for ContentModeVideo {
1899 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1900 write!(f, "contentModeVideo")
1901 }
1902}
1903
1904#[jacquard_derive::lexicon]
1905#[derive(
1906 serde::Serialize,
1907 serde::Deserialize,
1908 Debug,
1909 Clone,
1910 PartialEq,
1911 Eq,
1912 jacquard_derive::IntoStatic
1913)]
1914#[serde(rename_all = "camelCase")]
1915pub struct FeedViewPost<'a> {
1916 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1918 #[serde(borrow)]
1919 pub feed_context: Option<jacquard_common::CowStr<'a>>,
1920 #[serde(borrow)]
1921 pub post: crate::app_bsky::feed::PostView<'a>,
1922 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1923 #[serde(borrow)]
1924 pub reason: Option<FeedViewPostReason<'a>>,
1925 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1926 #[serde(borrow)]
1927 pub reply: Option<crate::app_bsky::feed::ReplyRef<'a>>,
1928 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1930 #[serde(borrow)]
1931 pub req_id: Option<jacquard_common::CowStr<'a>>,
1932}
1933
1934pub mod feed_view_post_state {
1935
1936 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
1937 #[allow(unused)]
1938 use ::core::marker::PhantomData;
1939 mod sealed {
1940 pub trait Sealed {}
1941 }
1942 pub trait State: sealed::Sealed {
1944 type Post;
1945 }
1946 pub struct Empty(());
1948 impl sealed::Sealed for Empty {}
1949 impl State for Empty {
1950 type Post = Unset;
1951 }
1952 pub struct SetPost<S: State = Empty>(PhantomData<fn() -> S>);
1954 impl<S: State> sealed::Sealed for SetPost<S> {}
1955 impl<S: State> State for SetPost<S> {
1956 type Post = Set<members::post>;
1957 }
1958 #[allow(non_camel_case_types)]
1960 pub mod members {
1961 pub struct post(());
1963 }
1964}
1965
1966pub struct FeedViewPostBuilder<'a, S: feed_view_post_state::State> {
1968 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
1969 __unsafe_private_named: (
1970 ::core::option::Option<jacquard_common::CowStr<'a>>,
1971 ::core::option::Option<crate::app_bsky::feed::PostView<'a>>,
1972 ::core::option::Option<FeedViewPostReason<'a>>,
1973 ::core::option::Option<crate::app_bsky::feed::ReplyRef<'a>>,
1974 ::core::option::Option<jacquard_common::CowStr<'a>>,
1975 ),
1976 _phantom: ::core::marker::PhantomData<&'a ()>,
1977}
1978
1979impl<'a> FeedViewPost<'a> {
1980 pub fn new() -> FeedViewPostBuilder<'a, feed_view_post_state::Empty> {
1982 FeedViewPostBuilder::new()
1983 }
1984}
1985
1986impl<'a> FeedViewPostBuilder<'a, feed_view_post_state::Empty> {
1987 pub fn new() -> Self {
1989 FeedViewPostBuilder {
1990 _phantom_state: ::core::marker::PhantomData,
1991 __unsafe_private_named: (None, None, None, None, None),
1992 _phantom: ::core::marker::PhantomData,
1993 }
1994 }
1995}
1996
1997impl<'a, S: feed_view_post_state::State> FeedViewPostBuilder<'a, S> {
1998 pub fn feed_context(
2000 mut self,
2001 value: impl Into<Option<jacquard_common::CowStr<'a>>>,
2002 ) -> Self {
2003 self.__unsafe_private_named.0 = value.into();
2004 self
2005 }
2006 pub fn maybe_feed_context(
2008 mut self,
2009 value: Option<jacquard_common::CowStr<'a>>,
2010 ) -> Self {
2011 self.__unsafe_private_named.0 = value;
2012 self
2013 }
2014}
2015
2016impl<'a, S> FeedViewPostBuilder<'a, S>
2017where
2018 S: feed_view_post_state::State,
2019 S::Post: feed_view_post_state::IsUnset,
2020{
2021 pub fn post(
2023 mut self,
2024 value: impl Into<crate::app_bsky::feed::PostView<'a>>,
2025 ) -> FeedViewPostBuilder<'a, feed_view_post_state::SetPost<S>> {
2026 self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
2027 FeedViewPostBuilder {
2028 _phantom_state: ::core::marker::PhantomData,
2029 __unsafe_private_named: self.__unsafe_private_named,
2030 _phantom: ::core::marker::PhantomData,
2031 }
2032 }
2033}
2034
2035impl<'a, S: feed_view_post_state::State> FeedViewPostBuilder<'a, S> {
2036 pub fn reason(mut self, value: impl Into<Option<FeedViewPostReason<'a>>>) -> Self {
2038 self.__unsafe_private_named.2 = value.into();
2039 self
2040 }
2041 pub fn maybe_reason(mut self, value: Option<FeedViewPostReason<'a>>) -> Self {
2043 self.__unsafe_private_named.2 = value;
2044 self
2045 }
2046}
2047
2048impl<'a, S: feed_view_post_state::State> FeedViewPostBuilder<'a, S> {
2049 pub fn reply(
2051 mut self,
2052 value: impl Into<Option<crate::app_bsky::feed::ReplyRef<'a>>>,
2053 ) -> Self {
2054 self.__unsafe_private_named.3 = value.into();
2055 self
2056 }
2057 pub fn maybe_reply(
2059 mut self,
2060 value: Option<crate::app_bsky::feed::ReplyRef<'a>>,
2061 ) -> Self {
2062 self.__unsafe_private_named.3 = value;
2063 self
2064 }
2065}
2066
2067impl<'a, S: feed_view_post_state::State> FeedViewPostBuilder<'a, S> {
2068 pub fn req_id(
2070 mut self,
2071 value: impl Into<Option<jacquard_common::CowStr<'a>>>,
2072 ) -> Self {
2073 self.__unsafe_private_named.4 = value.into();
2074 self
2075 }
2076 pub fn maybe_req_id(mut self, value: Option<jacquard_common::CowStr<'a>>) -> Self {
2078 self.__unsafe_private_named.4 = value;
2079 self
2080 }
2081}
2082
2083impl<'a, S> FeedViewPostBuilder<'a, S>
2084where
2085 S: feed_view_post_state::State,
2086 S::Post: feed_view_post_state::IsSet,
2087{
2088 pub fn build(self) -> FeedViewPost<'a> {
2090 FeedViewPost {
2091 feed_context: self.__unsafe_private_named.0,
2092 post: self.__unsafe_private_named.1.unwrap(),
2093 reason: self.__unsafe_private_named.2,
2094 reply: self.__unsafe_private_named.3,
2095 req_id: self.__unsafe_private_named.4,
2096 extra_data: Default::default(),
2097 }
2098 }
2099 pub fn build_with_data(
2101 self,
2102 extra_data: std::collections::BTreeMap<
2103 jacquard_common::smol_str::SmolStr,
2104 jacquard_common::types::value::Data<'a>,
2105 >,
2106 ) -> FeedViewPost<'a> {
2107 FeedViewPost {
2108 feed_context: self.__unsafe_private_named.0,
2109 post: self.__unsafe_private_named.1.unwrap(),
2110 reason: self.__unsafe_private_named.2,
2111 reply: self.__unsafe_private_named.3,
2112 req_id: self.__unsafe_private_named.4,
2113 extra_data: Some(extra_data),
2114 }
2115 }
2116}
2117
2118#[jacquard_derive::open_union]
2119#[derive(
2120 serde::Serialize,
2121 serde::Deserialize,
2122 Debug,
2123 Clone,
2124 PartialEq,
2125 Eq,
2126 jacquard_derive::IntoStatic
2127)]
2128#[serde(tag = "$type")]
2129#[serde(bound(deserialize = "'de: 'a"))]
2130pub enum FeedViewPostReason<'a> {
2131 #[serde(rename = "app.bsky.feed.defs#reasonRepost")]
2132 ReasonRepost(Box<crate::app_bsky::feed::ReasonRepost<'a>>),
2133 #[serde(rename = "app.bsky.feed.defs#reasonPin")]
2134 ReasonPin(Box<crate::app_bsky::feed::ReasonPin<'a>>),
2135}
2136
2137impl<'a> ::jacquard_lexicon::schema::LexiconSchema for FeedViewPost<'a> {
2138 fn nsid() -> &'static str {
2139 "app.bsky.feed.defs"
2140 }
2141 fn def_name() -> &'static str {
2142 "feedViewPost"
2143 }
2144 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
2145 lexicon_doc_app_bsky_feed_defs()
2146 }
2147 fn validate(
2148 &self,
2149 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
2150 if let Some(ref value) = self.feed_context {
2151 #[allow(unused_comparisons)]
2152 if <str>::len(value.as_ref()) > 2000usize {
2153 return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
2154 path: ::jacquard_lexicon::validation::ValidationPath::from_field(
2155 "feed_context",
2156 ),
2157 max: 2000usize,
2158 actual: <str>::len(value.as_ref()),
2159 });
2160 }
2161 }
2162 if let Some(ref value) = self.req_id {
2163 #[allow(unused_comparisons)]
2164 if <str>::len(value.as_ref()) > 100usize {
2165 return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
2166 path: ::jacquard_lexicon::validation::ValidationPath::from_field(
2167 "req_id",
2168 ),
2169 max: 100usize,
2170 actual: <str>::len(value.as_ref()),
2171 });
2172 }
2173 }
2174 Ok(())
2175 }
2176}
2177
2178#[jacquard_derive::lexicon]
2179#[derive(
2180 serde::Serialize,
2181 serde::Deserialize,
2182 Debug,
2183 Clone,
2184 PartialEq,
2185 Eq,
2186 jacquard_derive::IntoStatic
2187)]
2188#[serde(rename_all = "camelCase")]
2189pub struct GeneratorView<'a> {
2190 #[serde(skip_serializing_if = "std::option::Option::is_none")]
2191 pub accepts_interactions: Option<bool>,
2192 #[serde(skip_serializing_if = "std::option::Option::is_none")]
2193 #[serde(borrow)]
2194 pub avatar: Option<jacquard_common::types::string::Uri<'a>>,
2195 #[serde(borrow)]
2196 pub cid: jacquard_common::types::string::Cid<'a>,
2197 #[serde(skip_serializing_if = "std::option::Option::is_none")]
2198 #[serde(borrow)]
2199 pub content_mode: Option<jacquard_common::CowStr<'a>>,
2200 #[serde(borrow)]
2201 pub creator: crate::app_bsky::actor::ProfileView<'a>,
2202 #[serde(skip_serializing_if = "std::option::Option::is_none")]
2203 #[serde(borrow)]
2204 pub description: Option<jacquard_common::CowStr<'a>>,
2205 #[serde(skip_serializing_if = "std::option::Option::is_none")]
2206 #[serde(borrow)]
2207 pub description_facets: Option<Vec<crate::app_bsky::richtext::facet::Facet<'a>>>,
2208 #[serde(borrow)]
2209 pub did: jacquard_common::types::string::Did<'a>,
2210 #[serde(borrow)]
2211 pub display_name: jacquard_common::CowStr<'a>,
2212 pub indexed_at: jacquard_common::types::string::Datetime,
2213 #[serde(skip_serializing_if = "std::option::Option::is_none")]
2214 #[serde(borrow)]
2215 pub labels: Option<Vec<crate::com_atproto::label::Label<'a>>>,
2216 #[serde(skip_serializing_if = "std::option::Option::is_none")]
2217 pub like_count: Option<i64>,
2218 #[serde(borrow)]
2219 pub uri: jacquard_common::types::string::AtUri<'a>,
2220 #[serde(skip_serializing_if = "std::option::Option::is_none")]
2221 #[serde(borrow)]
2222 pub viewer: Option<crate::app_bsky::feed::GeneratorViewerState<'a>>,
2223}
2224
2225pub mod generator_view_state {
2226
2227 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
2228 #[allow(unused)]
2229 use ::core::marker::PhantomData;
2230 mod sealed {
2231 pub trait Sealed {}
2232 }
2233 pub trait State: sealed::Sealed {
2235 type Uri;
2236 type Cid;
2237 type Did;
2238 type Creator;
2239 type DisplayName;
2240 type IndexedAt;
2241 }
2242 pub struct Empty(());
2244 impl sealed::Sealed for Empty {}
2245 impl State for Empty {
2246 type Uri = Unset;
2247 type Cid = Unset;
2248 type Did = Unset;
2249 type Creator = Unset;
2250 type DisplayName = Unset;
2251 type IndexedAt = Unset;
2252 }
2253 pub struct SetUri<S: State = Empty>(PhantomData<fn() -> S>);
2255 impl<S: State> sealed::Sealed for SetUri<S> {}
2256 impl<S: State> State for SetUri<S> {
2257 type Uri = Set<members::uri>;
2258 type Cid = S::Cid;
2259 type Did = S::Did;
2260 type Creator = S::Creator;
2261 type DisplayName = S::DisplayName;
2262 type IndexedAt = S::IndexedAt;
2263 }
2264 pub struct SetCid<S: State = Empty>(PhantomData<fn() -> S>);
2266 impl<S: State> sealed::Sealed for SetCid<S> {}
2267 impl<S: State> State for SetCid<S> {
2268 type Uri = S::Uri;
2269 type Cid = Set<members::cid>;
2270 type Did = S::Did;
2271 type Creator = S::Creator;
2272 type DisplayName = S::DisplayName;
2273 type IndexedAt = S::IndexedAt;
2274 }
2275 pub struct SetDid<S: State = Empty>(PhantomData<fn() -> S>);
2277 impl<S: State> sealed::Sealed for SetDid<S> {}
2278 impl<S: State> State for SetDid<S> {
2279 type Uri = S::Uri;
2280 type Cid = S::Cid;
2281 type Did = Set<members::did>;
2282 type Creator = S::Creator;
2283 type DisplayName = S::DisplayName;
2284 type IndexedAt = S::IndexedAt;
2285 }
2286 pub struct SetCreator<S: State = Empty>(PhantomData<fn() -> S>);
2288 impl<S: State> sealed::Sealed for SetCreator<S> {}
2289 impl<S: State> State for SetCreator<S> {
2290 type Uri = S::Uri;
2291 type Cid = S::Cid;
2292 type Did = S::Did;
2293 type Creator = Set<members::creator>;
2294 type DisplayName = S::DisplayName;
2295 type IndexedAt = S::IndexedAt;
2296 }
2297 pub struct SetDisplayName<S: State = Empty>(PhantomData<fn() -> S>);
2299 impl<S: State> sealed::Sealed for SetDisplayName<S> {}
2300 impl<S: State> State for SetDisplayName<S> {
2301 type Uri = S::Uri;
2302 type Cid = S::Cid;
2303 type Did = S::Did;
2304 type Creator = S::Creator;
2305 type DisplayName = Set<members::display_name>;
2306 type IndexedAt = S::IndexedAt;
2307 }
2308 pub struct SetIndexedAt<S: State = Empty>(PhantomData<fn() -> S>);
2310 impl<S: State> sealed::Sealed for SetIndexedAt<S> {}
2311 impl<S: State> State for SetIndexedAt<S> {
2312 type Uri = S::Uri;
2313 type Cid = S::Cid;
2314 type Did = S::Did;
2315 type Creator = S::Creator;
2316 type DisplayName = S::DisplayName;
2317 type IndexedAt = Set<members::indexed_at>;
2318 }
2319 #[allow(non_camel_case_types)]
2321 pub mod members {
2322 pub struct uri(());
2324 pub struct cid(());
2326 pub struct did(());
2328 pub struct creator(());
2330 pub struct display_name(());
2332 pub struct indexed_at(());
2334 }
2335}
2336
2337pub struct GeneratorViewBuilder<'a, S: generator_view_state::State> {
2339 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
2340 __unsafe_private_named: (
2341 ::core::option::Option<bool>,
2342 ::core::option::Option<jacquard_common::types::string::Uri<'a>>,
2343 ::core::option::Option<jacquard_common::types::string::Cid<'a>>,
2344 ::core::option::Option<jacquard_common::CowStr<'a>>,
2345 ::core::option::Option<crate::app_bsky::actor::ProfileView<'a>>,
2346 ::core::option::Option<jacquard_common::CowStr<'a>>,
2347 ::core::option::Option<Vec<crate::app_bsky::richtext::facet::Facet<'a>>>,
2348 ::core::option::Option<jacquard_common::types::string::Did<'a>>,
2349 ::core::option::Option<jacquard_common::CowStr<'a>>,
2350 ::core::option::Option<jacquard_common::types::string::Datetime>,
2351 ::core::option::Option<Vec<crate::com_atproto::label::Label<'a>>>,
2352 ::core::option::Option<i64>,
2353 ::core::option::Option<jacquard_common::types::string::AtUri<'a>>,
2354 ::core::option::Option<crate::app_bsky::feed::GeneratorViewerState<'a>>,
2355 ),
2356 _phantom: ::core::marker::PhantomData<&'a ()>,
2357}
2358
2359impl<'a> GeneratorView<'a> {
2360 pub fn new() -> GeneratorViewBuilder<'a, generator_view_state::Empty> {
2362 GeneratorViewBuilder::new()
2363 }
2364}
2365
2366impl<'a> GeneratorViewBuilder<'a, generator_view_state::Empty> {
2367 pub fn new() -> Self {
2369 GeneratorViewBuilder {
2370 _phantom_state: ::core::marker::PhantomData,
2371 __unsafe_private_named: (
2372 None,
2373 None,
2374 None,
2375 None,
2376 None,
2377 None,
2378 None,
2379 None,
2380 None,
2381 None,
2382 None,
2383 None,
2384 None,
2385 None,
2386 ),
2387 _phantom: ::core::marker::PhantomData,
2388 }
2389 }
2390}
2391
2392impl<'a, S: generator_view_state::State> GeneratorViewBuilder<'a, S> {
2393 pub fn accepts_interactions(mut self, value: impl Into<Option<bool>>) -> Self {
2395 self.__unsafe_private_named.0 = value.into();
2396 self
2397 }
2398 pub fn maybe_accepts_interactions(mut self, value: Option<bool>) -> Self {
2400 self.__unsafe_private_named.0 = value;
2401 self
2402 }
2403}
2404
2405impl<'a, S: generator_view_state::State> GeneratorViewBuilder<'a, S> {
2406 pub fn avatar(
2408 mut self,
2409 value: impl Into<Option<jacquard_common::types::string::Uri<'a>>>,
2410 ) -> Self {
2411 self.__unsafe_private_named.1 = value.into();
2412 self
2413 }
2414 pub fn maybe_avatar(
2416 mut self,
2417 value: Option<jacquard_common::types::string::Uri<'a>>,
2418 ) -> Self {
2419 self.__unsafe_private_named.1 = value;
2420 self
2421 }
2422}
2423
2424impl<'a, S> GeneratorViewBuilder<'a, S>
2425where
2426 S: generator_view_state::State,
2427 S::Cid: generator_view_state::IsUnset,
2428{
2429 pub fn cid(
2431 mut self,
2432 value: impl Into<jacquard_common::types::string::Cid<'a>>,
2433 ) -> GeneratorViewBuilder<'a, generator_view_state::SetCid<S>> {
2434 self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into());
2435 GeneratorViewBuilder {
2436 _phantom_state: ::core::marker::PhantomData,
2437 __unsafe_private_named: self.__unsafe_private_named,
2438 _phantom: ::core::marker::PhantomData,
2439 }
2440 }
2441}
2442
2443impl<'a, S: generator_view_state::State> GeneratorViewBuilder<'a, S> {
2444 pub fn content_mode(
2446 mut self,
2447 value: impl Into<Option<jacquard_common::CowStr<'a>>>,
2448 ) -> Self {
2449 self.__unsafe_private_named.3 = value.into();
2450 self
2451 }
2452 pub fn maybe_content_mode(
2454 mut self,
2455 value: Option<jacquard_common::CowStr<'a>>,
2456 ) -> Self {
2457 self.__unsafe_private_named.3 = value;
2458 self
2459 }
2460}
2461
2462impl<'a, S> GeneratorViewBuilder<'a, S>
2463where
2464 S: generator_view_state::State,
2465 S::Creator: generator_view_state::IsUnset,
2466{
2467 pub fn creator(
2469 mut self,
2470 value: impl Into<crate::app_bsky::actor::ProfileView<'a>>,
2471 ) -> GeneratorViewBuilder<'a, generator_view_state::SetCreator<S>> {
2472 self.__unsafe_private_named.4 = ::core::option::Option::Some(value.into());
2473 GeneratorViewBuilder {
2474 _phantom_state: ::core::marker::PhantomData,
2475 __unsafe_private_named: self.__unsafe_private_named,
2476 _phantom: ::core::marker::PhantomData,
2477 }
2478 }
2479}
2480
2481impl<'a, S: generator_view_state::State> GeneratorViewBuilder<'a, S> {
2482 pub fn description(
2484 mut self,
2485 value: impl Into<Option<jacquard_common::CowStr<'a>>>,
2486 ) -> Self {
2487 self.__unsafe_private_named.5 = value.into();
2488 self
2489 }
2490 pub fn maybe_description(
2492 mut self,
2493 value: Option<jacquard_common::CowStr<'a>>,
2494 ) -> Self {
2495 self.__unsafe_private_named.5 = value;
2496 self
2497 }
2498}
2499
2500impl<'a, S: generator_view_state::State> GeneratorViewBuilder<'a, S> {
2501 pub fn description_facets(
2503 mut self,
2504 value: impl Into<Option<Vec<crate::app_bsky::richtext::facet::Facet<'a>>>>,
2505 ) -> Self {
2506 self.__unsafe_private_named.6 = value.into();
2507 self
2508 }
2509 pub fn maybe_description_facets(
2511 mut self,
2512 value: Option<Vec<crate::app_bsky::richtext::facet::Facet<'a>>>,
2513 ) -> Self {
2514 self.__unsafe_private_named.6 = value;
2515 self
2516 }
2517}
2518
2519impl<'a, S> GeneratorViewBuilder<'a, S>
2520where
2521 S: generator_view_state::State,
2522 S::Did: generator_view_state::IsUnset,
2523{
2524 pub fn did(
2526 mut self,
2527 value: impl Into<jacquard_common::types::string::Did<'a>>,
2528 ) -> GeneratorViewBuilder<'a, generator_view_state::SetDid<S>> {
2529 self.__unsafe_private_named.7 = ::core::option::Option::Some(value.into());
2530 GeneratorViewBuilder {
2531 _phantom_state: ::core::marker::PhantomData,
2532 __unsafe_private_named: self.__unsafe_private_named,
2533 _phantom: ::core::marker::PhantomData,
2534 }
2535 }
2536}
2537
2538impl<'a, S> GeneratorViewBuilder<'a, S>
2539where
2540 S: generator_view_state::State,
2541 S::DisplayName: generator_view_state::IsUnset,
2542{
2543 pub fn display_name(
2545 mut self,
2546 value: impl Into<jacquard_common::CowStr<'a>>,
2547 ) -> GeneratorViewBuilder<'a, generator_view_state::SetDisplayName<S>> {
2548 self.__unsafe_private_named.8 = ::core::option::Option::Some(value.into());
2549 GeneratorViewBuilder {
2550 _phantom_state: ::core::marker::PhantomData,
2551 __unsafe_private_named: self.__unsafe_private_named,
2552 _phantom: ::core::marker::PhantomData,
2553 }
2554 }
2555}
2556
2557impl<'a, S> GeneratorViewBuilder<'a, S>
2558where
2559 S: generator_view_state::State,
2560 S::IndexedAt: generator_view_state::IsUnset,
2561{
2562 pub fn indexed_at(
2564 mut self,
2565 value: impl Into<jacquard_common::types::string::Datetime>,
2566 ) -> GeneratorViewBuilder<'a, generator_view_state::SetIndexedAt<S>> {
2567 self.__unsafe_private_named.9 = ::core::option::Option::Some(value.into());
2568 GeneratorViewBuilder {
2569 _phantom_state: ::core::marker::PhantomData,
2570 __unsafe_private_named: self.__unsafe_private_named,
2571 _phantom: ::core::marker::PhantomData,
2572 }
2573 }
2574}
2575
2576impl<'a, S: generator_view_state::State> GeneratorViewBuilder<'a, S> {
2577 pub fn labels(
2579 mut self,
2580 value: impl Into<Option<Vec<crate::com_atproto::label::Label<'a>>>>,
2581 ) -> Self {
2582 self.__unsafe_private_named.10 = value.into();
2583 self
2584 }
2585 pub fn maybe_labels(
2587 mut self,
2588 value: Option<Vec<crate::com_atproto::label::Label<'a>>>,
2589 ) -> Self {
2590 self.__unsafe_private_named.10 = value;
2591 self
2592 }
2593}
2594
2595impl<'a, S: generator_view_state::State> GeneratorViewBuilder<'a, S> {
2596 pub fn like_count(mut self, value: impl Into<Option<i64>>) -> Self {
2598 self.__unsafe_private_named.11 = value.into();
2599 self
2600 }
2601 pub fn maybe_like_count(mut self, value: Option<i64>) -> Self {
2603 self.__unsafe_private_named.11 = value;
2604 self
2605 }
2606}
2607
2608impl<'a, S> GeneratorViewBuilder<'a, S>
2609where
2610 S: generator_view_state::State,
2611 S::Uri: generator_view_state::IsUnset,
2612{
2613 pub fn uri(
2615 mut self,
2616 value: impl Into<jacquard_common::types::string::AtUri<'a>>,
2617 ) -> GeneratorViewBuilder<'a, generator_view_state::SetUri<S>> {
2618 self.__unsafe_private_named.12 = ::core::option::Option::Some(value.into());
2619 GeneratorViewBuilder {
2620 _phantom_state: ::core::marker::PhantomData,
2621 __unsafe_private_named: self.__unsafe_private_named,
2622 _phantom: ::core::marker::PhantomData,
2623 }
2624 }
2625}
2626
2627impl<'a, S: generator_view_state::State> GeneratorViewBuilder<'a, S> {
2628 pub fn viewer(
2630 mut self,
2631 value: impl Into<Option<crate::app_bsky::feed::GeneratorViewerState<'a>>>,
2632 ) -> Self {
2633 self.__unsafe_private_named.13 = value.into();
2634 self
2635 }
2636 pub fn maybe_viewer(
2638 mut self,
2639 value: Option<crate::app_bsky::feed::GeneratorViewerState<'a>>,
2640 ) -> Self {
2641 self.__unsafe_private_named.13 = value;
2642 self
2643 }
2644}
2645
2646impl<'a, S> GeneratorViewBuilder<'a, S>
2647where
2648 S: generator_view_state::State,
2649 S::Uri: generator_view_state::IsSet,
2650 S::Cid: generator_view_state::IsSet,
2651 S::Did: generator_view_state::IsSet,
2652 S::Creator: generator_view_state::IsSet,
2653 S::DisplayName: generator_view_state::IsSet,
2654 S::IndexedAt: generator_view_state::IsSet,
2655{
2656 pub fn build(self) -> GeneratorView<'a> {
2658 GeneratorView {
2659 accepts_interactions: self.__unsafe_private_named.0,
2660 avatar: self.__unsafe_private_named.1,
2661 cid: self.__unsafe_private_named.2.unwrap(),
2662 content_mode: self.__unsafe_private_named.3,
2663 creator: self.__unsafe_private_named.4.unwrap(),
2664 description: self.__unsafe_private_named.5,
2665 description_facets: self.__unsafe_private_named.6,
2666 did: self.__unsafe_private_named.7.unwrap(),
2667 display_name: self.__unsafe_private_named.8.unwrap(),
2668 indexed_at: self.__unsafe_private_named.9.unwrap(),
2669 labels: self.__unsafe_private_named.10,
2670 like_count: self.__unsafe_private_named.11,
2671 uri: self.__unsafe_private_named.12.unwrap(),
2672 viewer: self.__unsafe_private_named.13,
2673 extra_data: Default::default(),
2674 }
2675 }
2676 pub fn build_with_data(
2678 self,
2679 extra_data: std::collections::BTreeMap<
2680 jacquard_common::smol_str::SmolStr,
2681 jacquard_common::types::value::Data<'a>,
2682 >,
2683 ) -> GeneratorView<'a> {
2684 GeneratorView {
2685 accepts_interactions: self.__unsafe_private_named.0,
2686 avatar: self.__unsafe_private_named.1,
2687 cid: self.__unsafe_private_named.2.unwrap(),
2688 content_mode: self.__unsafe_private_named.3,
2689 creator: self.__unsafe_private_named.4.unwrap(),
2690 description: self.__unsafe_private_named.5,
2691 description_facets: self.__unsafe_private_named.6,
2692 did: self.__unsafe_private_named.7.unwrap(),
2693 display_name: self.__unsafe_private_named.8.unwrap(),
2694 indexed_at: self.__unsafe_private_named.9.unwrap(),
2695 labels: self.__unsafe_private_named.10,
2696 like_count: self.__unsafe_private_named.11,
2697 uri: self.__unsafe_private_named.12.unwrap(),
2698 viewer: self.__unsafe_private_named.13,
2699 extra_data: Some(extra_data),
2700 }
2701 }
2702}
2703
2704impl<'a> ::jacquard_lexicon::schema::LexiconSchema for GeneratorView<'a> {
2705 fn nsid() -> &'static str {
2706 "app.bsky.feed.defs"
2707 }
2708 fn def_name() -> &'static str {
2709 "generatorView"
2710 }
2711 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
2712 lexicon_doc_app_bsky_feed_defs()
2713 }
2714 fn validate(
2715 &self,
2716 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
2717 if let Some(ref value) = self.description {
2718 #[allow(unused_comparisons)]
2719 if <str>::len(value.as_ref()) > 3000usize {
2720 return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
2721 path: ::jacquard_lexicon::validation::ValidationPath::from_field(
2722 "description",
2723 ),
2724 max: 3000usize,
2725 actual: <str>::len(value.as_ref()),
2726 });
2727 }
2728 }
2729 if let Some(ref value) = self.description {
2730 {
2731 let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
2732 value.as_ref(),
2733 true,
2734 )
2735 .count();
2736 if count > 300usize {
2737 return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes {
2738 path: ::jacquard_lexicon::validation::ValidationPath::from_field(
2739 "description",
2740 ),
2741 max: 300usize,
2742 actual: count,
2743 });
2744 }
2745 }
2746 }
2747 if let Some(ref value) = self.like_count {
2748 if *value < 0i64 {
2749 return Err(::jacquard_lexicon::validation::ConstraintError::Minimum {
2750 path: ::jacquard_lexicon::validation::ValidationPath::from_field(
2751 "like_count",
2752 ),
2753 min: 0i64,
2754 actual: *value,
2755 });
2756 }
2757 }
2758 Ok(())
2759 }
2760}
2761
2762#[jacquard_derive::lexicon]
2763#[derive(
2764 serde::Serialize,
2765 serde::Deserialize,
2766 Debug,
2767 Clone,
2768 PartialEq,
2769 Eq,
2770 jacquard_derive::IntoStatic,
2771 Default
2772)]
2773#[serde(rename_all = "camelCase")]
2774pub struct GeneratorViewerState<'a> {
2775 #[serde(skip_serializing_if = "std::option::Option::is_none")]
2776 #[serde(borrow)]
2777 pub like: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
2778}
2779
2780impl<'a> ::jacquard_lexicon::schema::LexiconSchema for GeneratorViewerState<'a> {
2781 fn nsid() -> &'static str {
2782 "app.bsky.feed.defs"
2783 }
2784 fn def_name() -> &'static str {
2785 "generatorViewerState"
2786 }
2787 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
2788 lexicon_doc_app_bsky_feed_defs()
2789 }
2790 fn validate(
2791 &self,
2792 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
2793 Ok(())
2794 }
2795}
2796
2797#[jacquard_derive::lexicon]
2798#[derive(
2799 serde::Serialize,
2800 serde::Deserialize,
2801 Debug,
2802 Clone,
2803 PartialEq,
2804 Eq,
2805 jacquard_derive::IntoStatic,
2806 Default
2807)]
2808#[serde(rename_all = "camelCase")]
2809pub struct Interaction<'a> {
2810 #[serde(skip_serializing_if = "std::option::Option::is_none")]
2811 #[serde(borrow)]
2812 pub event: std::option::Option<jacquard_common::CowStr<'a>>,
2813 #[serde(skip_serializing_if = "std::option::Option::is_none")]
2815 #[serde(borrow)]
2816 pub feed_context: std::option::Option<jacquard_common::CowStr<'a>>,
2817 #[serde(skip_serializing_if = "std::option::Option::is_none")]
2818 #[serde(borrow)]
2819 pub item: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
2820 #[serde(skip_serializing_if = "std::option::Option::is_none")]
2822 #[serde(borrow)]
2823 pub req_id: std::option::Option<jacquard_common::CowStr<'a>>,
2824}
2825
2826impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Interaction<'a> {
2827 fn nsid() -> &'static str {
2828 "app.bsky.feed.defs"
2829 }
2830 fn def_name() -> &'static str {
2831 "interaction"
2832 }
2833 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
2834 lexicon_doc_app_bsky_feed_defs()
2835 }
2836 fn validate(
2837 &self,
2838 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
2839 if let Some(ref value) = self.feed_context {
2840 #[allow(unused_comparisons)]
2841 if <str>::len(value.as_ref()) > 2000usize {
2842 return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
2843 path: ::jacquard_lexicon::validation::ValidationPath::from_field(
2844 "feed_context",
2845 ),
2846 max: 2000usize,
2847 actual: <str>::len(value.as_ref()),
2848 });
2849 }
2850 }
2851 if let Some(ref value) = self.req_id {
2852 #[allow(unused_comparisons)]
2853 if <str>::len(value.as_ref()) > 100usize {
2854 return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
2855 path: ::jacquard_lexicon::validation::ValidationPath::from_field(
2856 "req_id",
2857 ),
2858 max: 100usize,
2859 actual: <str>::len(value.as_ref()),
2860 });
2861 }
2862 }
2863 Ok(())
2864 }
2865}
2866
2867#[derive(
2869 serde::Serialize,
2870 serde::Deserialize,
2871 Debug,
2872 Clone,
2873 PartialEq,
2874 Eq,
2875 Hash,
2876 jacquard_derive::IntoStatic
2877)]
2878pub struct InteractionLike;
2879impl std::fmt::Display for InteractionLike {
2880 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2881 write!(f, "interactionLike")
2882 }
2883}
2884
2885#[derive(
2887 serde::Serialize,
2888 serde::Deserialize,
2889 Debug,
2890 Clone,
2891 PartialEq,
2892 Eq,
2893 Hash,
2894 jacquard_derive::IntoStatic
2895)]
2896pub struct InteractionQuote;
2897impl std::fmt::Display for InteractionQuote {
2898 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2899 write!(f, "interactionQuote")
2900 }
2901}
2902
2903#[derive(
2905 serde::Serialize,
2906 serde::Deserialize,
2907 Debug,
2908 Clone,
2909 PartialEq,
2910 Eq,
2911 Hash,
2912 jacquard_derive::IntoStatic
2913)]
2914pub struct InteractionReply;
2915impl std::fmt::Display for InteractionReply {
2916 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2917 write!(f, "interactionReply")
2918 }
2919}
2920
2921#[derive(
2923 serde::Serialize,
2924 serde::Deserialize,
2925 Debug,
2926 Clone,
2927 PartialEq,
2928 Eq,
2929 Hash,
2930 jacquard_derive::IntoStatic
2931)]
2932pub struct InteractionRepost;
2933impl std::fmt::Display for InteractionRepost {
2934 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2935 write!(f, "interactionRepost")
2936 }
2937}
2938
2939#[derive(
2941 serde::Serialize,
2942 serde::Deserialize,
2943 Debug,
2944 Clone,
2945 PartialEq,
2946 Eq,
2947 Hash,
2948 jacquard_derive::IntoStatic
2949)]
2950pub struct InteractionSeen;
2951impl std::fmt::Display for InteractionSeen {
2952 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2953 write!(f, "interactionSeen")
2954 }
2955}
2956
2957#[derive(
2959 serde::Serialize,
2960 serde::Deserialize,
2961 Debug,
2962 Clone,
2963 PartialEq,
2964 Eq,
2965 Hash,
2966 jacquard_derive::IntoStatic
2967)]
2968pub struct InteractionShare;
2969impl std::fmt::Display for InteractionShare {
2970 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2971 write!(f, "interactionShare")
2972 }
2973}
2974
2975#[jacquard_derive::lexicon]
2976#[derive(
2977 serde::Serialize,
2978 serde::Deserialize,
2979 Debug,
2980 Clone,
2981 PartialEq,
2982 Eq,
2983 jacquard_derive::IntoStatic
2984)]
2985#[serde(rename_all = "camelCase")]
2986pub struct NotFoundPost<'a> {
2987 pub not_found: bool,
2988 #[serde(borrow)]
2989 pub uri: jacquard_common::types::string::AtUri<'a>,
2990}
2991
2992pub mod not_found_post_state {
2993
2994 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
2995 #[allow(unused)]
2996 use ::core::marker::PhantomData;
2997 mod sealed {
2998 pub trait Sealed {}
2999 }
3000 pub trait State: sealed::Sealed {
3002 type Uri;
3003 type NotFound;
3004 }
3005 pub struct Empty(());
3007 impl sealed::Sealed for Empty {}
3008 impl State for Empty {
3009 type Uri = Unset;
3010 type NotFound = Unset;
3011 }
3012 pub struct SetUri<S: State = Empty>(PhantomData<fn() -> S>);
3014 impl<S: State> sealed::Sealed for SetUri<S> {}
3015 impl<S: State> State for SetUri<S> {
3016 type Uri = Set<members::uri>;
3017 type NotFound = S::NotFound;
3018 }
3019 pub struct SetNotFound<S: State = Empty>(PhantomData<fn() -> S>);
3021 impl<S: State> sealed::Sealed for SetNotFound<S> {}
3022 impl<S: State> State for SetNotFound<S> {
3023 type Uri = S::Uri;
3024 type NotFound = Set<members::not_found>;
3025 }
3026 #[allow(non_camel_case_types)]
3028 pub mod members {
3029 pub struct uri(());
3031 pub struct not_found(());
3033 }
3034}
3035
3036pub struct NotFoundPostBuilder<'a, S: not_found_post_state::State> {
3038 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
3039 __unsafe_private_named: (
3040 ::core::option::Option<bool>,
3041 ::core::option::Option<jacquard_common::types::string::AtUri<'a>>,
3042 ),
3043 _phantom: ::core::marker::PhantomData<&'a ()>,
3044}
3045
3046impl<'a> NotFoundPost<'a> {
3047 pub fn new() -> NotFoundPostBuilder<'a, not_found_post_state::Empty> {
3049 NotFoundPostBuilder::new()
3050 }
3051}
3052
3053impl<'a> NotFoundPostBuilder<'a, not_found_post_state::Empty> {
3054 pub fn new() -> Self {
3056 NotFoundPostBuilder {
3057 _phantom_state: ::core::marker::PhantomData,
3058 __unsafe_private_named: (None, None),
3059 _phantom: ::core::marker::PhantomData,
3060 }
3061 }
3062}
3063
3064impl<'a, S> NotFoundPostBuilder<'a, S>
3065where
3066 S: not_found_post_state::State,
3067 S::NotFound: not_found_post_state::IsUnset,
3068{
3069 pub fn not_found(
3071 mut self,
3072 value: impl Into<bool>,
3073 ) -> NotFoundPostBuilder<'a, not_found_post_state::SetNotFound<S>> {
3074 self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
3075 NotFoundPostBuilder {
3076 _phantom_state: ::core::marker::PhantomData,
3077 __unsafe_private_named: self.__unsafe_private_named,
3078 _phantom: ::core::marker::PhantomData,
3079 }
3080 }
3081}
3082
3083impl<'a, S> NotFoundPostBuilder<'a, S>
3084where
3085 S: not_found_post_state::State,
3086 S::Uri: not_found_post_state::IsUnset,
3087{
3088 pub fn uri(
3090 mut self,
3091 value: impl Into<jacquard_common::types::string::AtUri<'a>>,
3092 ) -> NotFoundPostBuilder<'a, not_found_post_state::SetUri<S>> {
3093 self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
3094 NotFoundPostBuilder {
3095 _phantom_state: ::core::marker::PhantomData,
3096 __unsafe_private_named: self.__unsafe_private_named,
3097 _phantom: ::core::marker::PhantomData,
3098 }
3099 }
3100}
3101
3102impl<'a, S> NotFoundPostBuilder<'a, S>
3103where
3104 S: not_found_post_state::State,
3105 S::Uri: not_found_post_state::IsSet,
3106 S::NotFound: not_found_post_state::IsSet,
3107{
3108 pub fn build(self) -> NotFoundPost<'a> {
3110 NotFoundPost {
3111 not_found: self.__unsafe_private_named.0.unwrap(),
3112 uri: self.__unsafe_private_named.1.unwrap(),
3113 extra_data: Default::default(),
3114 }
3115 }
3116 pub fn build_with_data(
3118 self,
3119 extra_data: std::collections::BTreeMap<
3120 jacquard_common::smol_str::SmolStr,
3121 jacquard_common::types::value::Data<'a>,
3122 >,
3123 ) -> NotFoundPost<'a> {
3124 NotFoundPost {
3125 not_found: self.__unsafe_private_named.0.unwrap(),
3126 uri: self.__unsafe_private_named.1.unwrap(),
3127 extra_data: Some(extra_data),
3128 }
3129 }
3130}
3131
3132impl<'a> ::jacquard_lexicon::schema::LexiconSchema for NotFoundPost<'a> {
3133 fn nsid() -> &'static str {
3134 "app.bsky.feed.defs"
3135 }
3136 fn def_name() -> &'static str {
3137 "notFoundPost"
3138 }
3139 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
3140 lexicon_doc_app_bsky_feed_defs()
3141 }
3142 fn validate(
3143 &self,
3144 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
3145 Ok(())
3146 }
3147}
3148
3149#[jacquard_derive::lexicon]
3150#[derive(
3151 serde::Serialize,
3152 serde::Deserialize,
3153 Debug,
3154 Clone,
3155 PartialEq,
3156 Eq,
3157 jacquard_derive::IntoStatic
3158)]
3159#[serde(rename_all = "camelCase")]
3160pub struct PostView<'a> {
3161 #[serde(borrow)]
3162 pub author: crate::app_bsky::actor::ProfileViewBasic<'a>,
3163 #[serde(skip_serializing_if = "std::option::Option::is_none")]
3164 pub bookmark_count: Option<i64>,
3165 #[serde(borrow)]
3166 pub cid: jacquard_common::types::string::Cid<'a>,
3167 #[serde(skip_serializing_if = "std::option::Option::is_none")]
3169 #[serde(borrow)]
3170 pub debug: Option<jacquard_common::types::value::Data<'a>>,
3171 #[serde(skip_serializing_if = "std::option::Option::is_none")]
3172 #[serde(borrow)]
3173 pub embed: Option<PostViewEmbed<'a>>,
3174 pub indexed_at: jacquard_common::types::string::Datetime,
3175 #[serde(skip_serializing_if = "std::option::Option::is_none")]
3176 #[serde(borrow)]
3177 pub labels: Option<Vec<crate::com_atproto::label::Label<'a>>>,
3178 #[serde(skip_serializing_if = "std::option::Option::is_none")]
3179 pub like_count: Option<i64>,
3180 #[serde(skip_serializing_if = "std::option::Option::is_none")]
3181 pub quote_count: Option<i64>,
3182 #[serde(borrow)]
3183 pub record: jacquard_common::types::value::Data<'a>,
3184 #[serde(skip_serializing_if = "std::option::Option::is_none")]
3185 pub reply_count: Option<i64>,
3186 #[serde(skip_serializing_if = "std::option::Option::is_none")]
3187 pub repost_count: Option<i64>,
3188 #[serde(skip_serializing_if = "std::option::Option::is_none")]
3189 #[serde(borrow)]
3190 pub threadgate: Option<crate::app_bsky::feed::ThreadgateView<'a>>,
3191 #[serde(borrow)]
3192 pub uri: jacquard_common::types::string::AtUri<'a>,
3193 #[serde(skip_serializing_if = "std::option::Option::is_none")]
3194 #[serde(borrow)]
3195 pub viewer: Option<crate::app_bsky::feed::ViewerState<'a>>,
3196}
3197
3198pub mod post_view_state {
3199
3200 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
3201 #[allow(unused)]
3202 use ::core::marker::PhantomData;
3203 mod sealed {
3204 pub trait Sealed {}
3205 }
3206 pub trait State: sealed::Sealed {
3208 type Uri;
3209 type Cid;
3210 type Author;
3211 type Record;
3212 type IndexedAt;
3213 }
3214 pub struct Empty(());
3216 impl sealed::Sealed for Empty {}
3217 impl State for Empty {
3218 type Uri = Unset;
3219 type Cid = Unset;
3220 type Author = Unset;
3221 type Record = Unset;
3222 type IndexedAt = Unset;
3223 }
3224 pub struct SetUri<S: State = Empty>(PhantomData<fn() -> S>);
3226 impl<S: State> sealed::Sealed for SetUri<S> {}
3227 impl<S: State> State for SetUri<S> {
3228 type Uri = Set<members::uri>;
3229 type Cid = S::Cid;
3230 type Author = S::Author;
3231 type Record = S::Record;
3232 type IndexedAt = S::IndexedAt;
3233 }
3234 pub struct SetCid<S: State = Empty>(PhantomData<fn() -> S>);
3236 impl<S: State> sealed::Sealed for SetCid<S> {}
3237 impl<S: State> State for SetCid<S> {
3238 type Uri = S::Uri;
3239 type Cid = Set<members::cid>;
3240 type Author = S::Author;
3241 type Record = S::Record;
3242 type IndexedAt = S::IndexedAt;
3243 }
3244 pub struct SetAuthor<S: State = Empty>(PhantomData<fn() -> S>);
3246 impl<S: State> sealed::Sealed for SetAuthor<S> {}
3247 impl<S: State> State for SetAuthor<S> {
3248 type Uri = S::Uri;
3249 type Cid = S::Cid;
3250 type Author = Set<members::author>;
3251 type Record = S::Record;
3252 type IndexedAt = S::IndexedAt;
3253 }
3254 pub struct SetRecord<S: State = Empty>(PhantomData<fn() -> S>);
3256 impl<S: State> sealed::Sealed for SetRecord<S> {}
3257 impl<S: State> State for SetRecord<S> {
3258 type Uri = S::Uri;
3259 type Cid = S::Cid;
3260 type Author = S::Author;
3261 type Record = Set<members::record>;
3262 type IndexedAt = S::IndexedAt;
3263 }
3264 pub struct SetIndexedAt<S: State = Empty>(PhantomData<fn() -> S>);
3266 impl<S: State> sealed::Sealed for SetIndexedAt<S> {}
3267 impl<S: State> State for SetIndexedAt<S> {
3268 type Uri = S::Uri;
3269 type Cid = S::Cid;
3270 type Author = S::Author;
3271 type Record = S::Record;
3272 type IndexedAt = Set<members::indexed_at>;
3273 }
3274 #[allow(non_camel_case_types)]
3276 pub mod members {
3277 pub struct uri(());
3279 pub struct cid(());
3281 pub struct author(());
3283 pub struct record(());
3285 pub struct indexed_at(());
3287 }
3288}
3289
3290pub struct PostViewBuilder<'a, S: post_view_state::State> {
3292 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
3293 __unsafe_private_named: (
3294 ::core::option::Option<crate::app_bsky::actor::ProfileViewBasic<'a>>,
3295 ::core::option::Option<i64>,
3296 ::core::option::Option<jacquard_common::types::string::Cid<'a>>,
3297 ::core::option::Option<jacquard_common::types::value::Data<'a>>,
3298 ::core::option::Option<PostViewEmbed<'a>>,
3299 ::core::option::Option<jacquard_common::types::string::Datetime>,
3300 ::core::option::Option<Vec<crate::com_atproto::label::Label<'a>>>,
3301 ::core::option::Option<i64>,
3302 ::core::option::Option<i64>,
3303 ::core::option::Option<jacquard_common::types::value::Data<'a>>,
3304 ::core::option::Option<i64>,
3305 ::core::option::Option<i64>,
3306 ::core::option::Option<crate::app_bsky::feed::ThreadgateView<'a>>,
3307 ::core::option::Option<jacquard_common::types::string::AtUri<'a>>,
3308 ::core::option::Option<crate::app_bsky::feed::ViewerState<'a>>,
3309 ),
3310 _phantom: ::core::marker::PhantomData<&'a ()>,
3311}
3312
3313impl<'a> PostView<'a> {
3314 pub fn new() -> PostViewBuilder<'a, post_view_state::Empty> {
3316 PostViewBuilder::new()
3317 }
3318}
3319
3320impl<'a> PostViewBuilder<'a, post_view_state::Empty> {
3321 pub fn new() -> Self {
3323 PostViewBuilder {
3324 _phantom_state: ::core::marker::PhantomData,
3325 __unsafe_private_named: (
3326 None,
3327 None,
3328 None,
3329 None,
3330 None,
3331 None,
3332 None,
3333 None,
3334 None,
3335 None,
3336 None,
3337 None,
3338 None,
3339 None,
3340 None,
3341 ),
3342 _phantom: ::core::marker::PhantomData,
3343 }
3344 }
3345}
3346
3347impl<'a, S> PostViewBuilder<'a, S>
3348where
3349 S: post_view_state::State,
3350 S::Author: post_view_state::IsUnset,
3351{
3352 pub fn author(
3354 mut self,
3355 value: impl Into<crate::app_bsky::actor::ProfileViewBasic<'a>>,
3356 ) -> PostViewBuilder<'a, post_view_state::SetAuthor<S>> {
3357 self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
3358 PostViewBuilder {
3359 _phantom_state: ::core::marker::PhantomData,
3360 __unsafe_private_named: self.__unsafe_private_named,
3361 _phantom: ::core::marker::PhantomData,
3362 }
3363 }
3364}
3365
3366impl<'a, S: post_view_state::State> PostViewBuilder<'a, S> {
3367 pub fn bookmark_count(mut self, value: impl Into<Option<i64>>) -> Self {
3369 self.__unsafe_private_named.1 = value.into();
3370 self
3371 }
3372 pub fn maybe_bookmark_count(mut self, value: Option<i64>) -> Self {
3374 self.__unsafe_private_named.1 = value;
3375 self
3376 }
3377}
3378
3379impl<'a, S> PostViewBuilder<'a, S>
3380where
3381 S: post_view_state::State,
3382 S::Cid: post_view_state::IsUnset,
3383{
3384 pub fn cid(
3386 mut self,
3387 value: impl Into<jacquard_common::types::string::Cid<'a>>,
3388 ) -> PostViewBuilder<'a, post_view_state::SetCid<S>> {
3389 self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into());
3390 PostViewBuilder {
3391 _phantom_state: ::core::marker::PhantomData,
3392 __unsafe_private_named: self.__unsafe_private_named,
3393 _phantom: ::core::marker::PhantomData,
3394 }
3395 }
3396}
3397
3398impl<'a, S: post_view_state::State> PostViewBuilder<'a, S> {
3399 pub fn debug(
3401 mut self,
3402 value: impl Into<Option<jacquard_common::types::value::Data<'a>>>,
3403 ) -> Self {
3404 self.__unsafe_private_named.3 = value.into();
3405 self
3406 }
3407 pub fn maybe_debug(
3409 mut self,
3410 value: Option<jacquard_common::types::value::Data<'a>>,
3411 ) -> Self {
3412 self.__unsafe_private_named.3 = value;
3413 self
3414 }
3415}
3416
3417impl<'a, S: post_view_state::State> PostViewBuilder<'a, S> {
3418 pub fn embed(mut self, value: impl Into<Option<PostViewEmbed<'a>>>) -> Self {
3420 self.__unsafe_private_named.4 = value.into();
3421 self
3422 }
3423 pub fn maybe_embed(mut self, value: Option<PostViewEmbed<'a>>) -> Self {
3425 self.__unsafe_private_named.4 = value;
3426 self
3427 }
3428}
3429
3430impl<'a, S> PostViewBuilder<'a, S>
3431where
3432 S: post_view_state::State,
3433 S::IndexedAt: post_view_state::IsUnset,
3434{
3435 pub fn indexed_at(
3437 mut self,
3438 value: impl Into<jacquard_common::types::string::Datetime>,
3439 ) -> PostViewBuilder<'a, post_view_state::SetIndexedAt<S>> {
3440 self.__unsafe_private_named.5 = ::core::option::Option::Some(value.into());
3441 PostViewBuilder {
3442 _phantom_state: ::core::marker::PhantomData,
3443 __unsafe_private_named: self.__unsafe_private_named,
3444 _phantom: ::core::marker::PhantomData,
3445 }
3446 }
3447}
3448
3449impl<'a, S: post_view_state::State> PostViewBuilder<'a, S> {
3450 pub fn labels(
3452 mut self,
3453 value: impl Into<Option<Vec<crate::com_atproto::label::Label<'a>>>>,
3454 ) -> Self {
3455 self.__unsafe_private_named.6 = value.into();
3456 self
3457 }
3458 pub fn maybe_labels(
3460 mut self,
3461 value: Option<Vec<crate::com_atproto::label::Label<'a>>>,
3462 ) -> Self {
3463 self.__unsafe_private_named.6 = value;
3464 self
3465 }
3466}
3467
3468impl<'a, S: post_view_state::State> PostViewBuilder<'a, S> {
3469 pub fn like_count(mut self, value: impl Into<Option<i64>>) -> Self {
3471 self.__unsafe_private_named.7 = value.into();
3472 self
3473 }
3474 pub fn maybe_like_count(mut self, value: Option<i64>) -> Self {
3476 self.__unsafe_private_named.7 = value;
3477 self
3478 }
3479}
3480
3481impl<'a, S: post_view_state::State> PostViewBuilder<'a, S> {
3482 pub fn quote_count(mut self, value: impl Into<Option<i64>>) -> Self {
3484 self.__unsafe_private_named.8 = value.into();
3485 self
3486 }
3487 pub fn maybe_quote_count(mut self, value: Option<i64>) -> Self {
3489 self.__unsafe_private_named.8 = value;
3490 self
3491 }
3492}
3493
3494impl<'a, S> PostViewBuilder<'a, S>
3495where
3496 S: post_view_state::State,
3497 S::Record: post_view_state::IsUnset,
3498{
3499 pub fn record(
3501 mut self,
3502 value: impl Into<jacquard_common::types::value::Data<'a>>,
3503 ) -> PostViewBuilder<'a, post_view_state::SetRecord<S>> {
3504 self.__unsafe_private_named.9 = ::core::option::Option::Some(value.into());
3505 PostViewBuilder {
3506 _phantom_state: ::core::marker::PhantomData,
3507 __unsafe_private_named: self.__unsafe_private_named,
3508 _phantom: ::core::marker::PhantomData,
3509 }
3510 }
3511}
3512
3513impl<'a, S: post_view_state::State> PostViewBuilder<'a, S> {
3514 pub fn reply_count(mut self, value: impl Into<Option<i64>>) -> Self {
3516 self.__unsafe_private_named.10 = value.into();
3517 self
3518 }
3519 pub fn maybe_reply_count(mut self, value: Option<i64>) -> Self {
3521 self.__unsafe_private_named.10 = value;
3522 self
3523 }
3524}
3525
3526impl<'a, S: post_view_state::State> PostViewBuilder<'a, S> {
3527 pub fn repost_count(mut self, value: impl Into<Option<i64>>) -> Self {
3529 self.__unsafe_private_named.11 = value.into();
3530 self
3531 }
3532 pub fn maybe_repost_count(mut self, value: Option<i64>) -> Self {
3534 self.__unsafe_private_named.11 = value;
3535 self
3536 }
3537}
3538
3539impl<'a, S: post_view_state::State> PostViewBuilder<'a, S> {
3540 pub fn threadgate(
3542 mut self,
3543 value: impl Into<Option<crate::app_bsky::feed::ThreadgateView<'a>>>,
3544 ) -> Self {
3545 self.__unsafe_private_named.12 = value.into();
3546 self
3547 }
3548 pub fn maybe_threadgate(
3550 mut self,
3551 value: Option<crate::app_bsky::feed::ThreadgateView<'a>>,
3552 ) -> Self {
3553 self.__unsafe_private_named.12 = value;
3554 self
3555 }
3556}
3557
3558impl<'a, S> PostViewBuilder<'a, S>
3559where
3560 S: post_view_state::State,
3561 S::Uri: post_view_state::IsUnset,
3562{
3563 pub fn uri(
3565 mut self,
3566 value: impl Into<jacquard_common::types::string::AtUri<'a>>,
3567 ) -> PostViewBuilder<'a, post_view_state::SetUri<S>> {
3568 self.__unsafe_private_named.13 = ::core::option::Option::Some(value.into());
3569 PostViewBuilder {
3570 _phantom_state: ::core::marker::PhantomData,
3571 __unsafe_private_named: self.__unsafe_private_named,
3572 _phantom: ::core::marker::PhantomData,
3573 }
3574 }
3575}
3576
3577impl<'a, S: post_view_state::State> PostViewBuilder<'a, S> {
3578 pub fn viewer(
3580 mut self,
3581 value: impl Into<Option<crate::app_bsky::feed::ViewerState<'a>>>,
3582 ) -> Self {
3583 self.__unsafe_private_named.14 = value.into();
3584 self
3585 }
3586 pub fn maybe_viewer(
3588 mut self,
3589 value: Option<crate::app_bsky::feed::ViewerState<'a>>,
3590 ) -> Self {
3591 self.__unsafe_private_named.14 = value;
3592 self
3593 }
3594}
3595
3596impl<'a, S> PostViewBuilder<'a, S>
3597where
3598 S: post_view_state::State,
3599 S::Uri: post_view_state::IsSet,
3600 S::Cid: post_view_state::IsSet,
3601 S::Author: post_view_state::IsSet,
3602 S::Record: post_view_state::IsSet,
3603 S::IndexedAt: post_view_state::IsSet,
3604{
3605 pub fn build(self) -> PostView<'a> {
3607 PostView {
3608 author: self.__unsafe_private_named.0.unwrap(),
3609 bookmark_count: self.__unsafe_private_named.1,
3610 cid: self.__unsafe_private_named.2.unwrap(),
3611 debug: self.__unsafe_private_named.3,
3612 embed: self.__unsafe_private_named.4,
3613 indexed_at: self.__unsafe_private_named.5.unwrap(),
3614 labels: self.__unsafe_private_named.6,
3615 like_count: self.__unsafe_private_named.7,
3616 quote_count: self.__unsafe_private_named.8,
3617 record: self.__unsafe_private_named.9.unwrap(),
3618 reply_count: self.__unsafe_private_named.10,
3619 repost_count: self.__unsafe_private_named.11,
3620 threadgate: self.__unsafe_private_named.12,
3621 uri: self.__unsafe_private_named.13.unwrap(),
3622 viewer: self.__unsafe_private_named.14,
3623 extra_data: Default::default(),
3624 }
3625 }
3626 pub fn build_with_data(
3628 self,
3629 extra_data: std::collections::BTreeMap<
3630 jacquard_common::smol_str::SmolStr,
3631 jacquard_common::types::value::Data<'a>,
3632 >,
3633 ) -> PostView<'a> {
3634 PostView {
3635 author: self.__unsafe_private_named.0.unwrap(),
3636 bookmark_count: self.__unsafe_private_named.1,
3637 cid: self.__unsafe_private_named.2.unwrap(),
3638 debug: self.__unsafe_private_named.3,
3639 embed: self.__unsafe_private_named.4,
3640 indexed_at: self.__unsafe_private_named.5.unwrap(),
3641 labels: self.__unsafe_private_named.6,
3642 like_count: self.__unsafe_private_named.7,
3643 quote_count: self.__unsafe_private_named.8,
3644 record: self.__unsafe_private_named.9.unwrap(),
3645 reply_count: self.__unsafe_private_named.10,
3646 repost_count: self.__unsafe_private_named.11,
3647 threadgate: self.__unsafe_private_named.12,
3648 uri: self.__unsafe_private_named.13.unwrap(),
3649 viewer: self.__unsafe_private_named.14,
3650 extra_data: Some(extra_data),
3651 }
3652 }
3653}
3654
3655#[jacquard_derive::open_union]
3656#[derive(
3657 serde::Serialize,
3658 serde::Deserialize,
3659 Debug,
3660 Clone,
3661 PartialEq,
3662 Eq,
3663 jacquard_derive::IntoStatic
3664)]
3665#[serde(tag = "$type")]
3666#[serde(bound(deserialize = "'de: 'a"))]
3667pub enum PostViewEmbed<'a> {
3668 #[serde(rename = "app.bsky.embed.images#view")]
3669 ImagesView(Box<crate::app_bsky::embed::images::View<'a>>),
3670 #[serde(rename = "app.bsky.embed.video#view")]
3671 VideoView(Box<crate::app_bsky::embed::video::View<'a>>),
3672 #[serde(rename = "app.bsky.embed.external#view")]
3673 ExternalView(Box<crate::app_bsky::embed::external::View<'a>>),
3674 #[serde(rename = "app.bsky.embed.record#view")]
3675 RecordView(Box<crate::app_bsky::embed::record::View<'a>>),
3676 #[serde(rename = "app.bsky.embed.recordWithMedia#view")]
3677 RecordWithMediaView(Box<crate::app_bsky::embed::record_with_media::View<'a>>),
3678}
3679
3680impl<'a> ::jacquard_lexicon::schema::LexiconSchema for PostView<'a> {
3681 fn nsid() -> &'static str {
3682 "app.bsky.feed.defs"
3683 }
3684 fn def_name() -> &'static str {
3685 "postView"
3686 }
3687 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
3688 lexicon_doc_app_bsky_feed_defs()
3689 }
3690 fn validate(
3691 &self,
3692 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
3693 Ok(())
3694 }
3695}
3696
3697#[jacquard_derive::lexicon]
3698#[derive(
3699 serde::Serialize,
3700 serde::Deserialize,
3701 Debug,
3702 Clone,
3703 PartialEq,
3704 Eq,
3705 jacquard_derive::IntoStatic,
3706 Default
3707)]
3708#[serde(rename_all = "camelCase")]
3709pub struct ReasonPin<'a> {}
3710impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ReasonPin<'a> {
3711 fn nsid() -> &'static str {
3712 "app.bsky.feed.defs"
3713 }
3714 fn def_name() -> &'static str {
3715 "reasonPin"
3716 }
3717 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
3718 lexicon_doc_app_bsky_feed_defs()
3719 }
3720 fn validate(
3721 &self,
3722 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
3723 Ok(())
3724 }
3725}
3726
3727#[jacquard_derive::lexicon]
3728#[derive(
3729 serde::Serialize,
3730 serde::Deserialize,
3731 Debug,
3732 Clone,
3733 PartialEq,
3734 Eq,
3735 jacquard_derive::IntoStatic
3736)]
3737#[serde(rename_all = "camelCase")]
3738pub struct ReasonRepost<'a> {
3739 #[serde(borrow)]
3740 pub by: crate::app_bsky::actor::ProfileViewBasic<'a>,
3741 #[serde(skip_serializing_if = "std::option::Option::is_none")]
3742 #[serde(borrow)]
3743 pub cid: Option<jacquard_common::types::string::Cid<'a>>,
3744 pub indexed_at: jacquard_common::types::string::Datetime,
3745 #[serde(skip_serializing_if = "std::option::Option::is_none")]
3746 #[serde(borrow)]
3747 pub uri: Option<jacquard_common::types::string::AtUri<'a>>,
3748}
3749
3750pub mod reason_repost_state {
3751
3752 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
3753 #[allow(unused)]
3754 use ::core::marker::PhantomData;
3755 mod sealed {
3756 pub trait Sealed {}
3757 }
3758 pub trait State: sealed::Sealed {
3760 type By;
3761 type IndexedAt;
3762 }
3763 pub struct Empty(());
3765 impl sealed::Sealed for Empty {}
3766 impl State for Empty {
3767 type By = Unset;
3768 type IndexedAt = Unset;
3769 }
3770 pub struct SetBy<S: State = Empty>(PhantomData<fn() -> S>);
3772 impl<S: State> sealed::Sealed for SetBy<S> {}
3773 impl<S: State> State for SetBy<S> {
3774 type By = Set<members::by>;
3775 type IndexedAt = S::IndexedAt;
3776 }
3777 pub struct SetIndexedAt<S: State = Empty>(PhantomData<fn() -> S>);
3779 impl<S: State> sealed::Sealed for SetIndexedAt<S> {}
3780 impl<S: State> State for SetIndexedAt<S> {
3781 type By = S::By;
3782 type IndexedAt = Set<members::indexed_at>;
3783 }
3784 #[allow(non_camel_case_types)]
3786 pub mod members {
3787 pub struct by(());
3789 pub struct indexed_at(());
3791 }
3792}
3793
3794pub struct ReasonRepostBuilder<'a, S: reason_repost_state::State> {
3796 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
3797 __unsafe_private_named: (
3798 ::core::option::Option<crate::app_bsky::actor::ProfileViewBasic<'a>>,
3799 ::core::option::Option<jacquard_common::types::string::Cid<'a>>,
3800 ::core::option::Option<jacquard_common::types::string::Datetime>,
3801 ::core::option::Option<jacquard_common::types::string::AtUri<'a>>,
3802 ),
3803 _phantom: ::core::marker::PhantomData<&'a ()>,
3804}
3805
3806impl<'a> ReasonRepost<'a> {
3807 pub fn new() -> ReasonRepostBuilder<'a, reason_repost_state::Empty> {
3809 ReasonRepostBuilder::new()
3810 }
3811}
3812
3813impl<'a> ReasonRepostBuilder<'a, reason_repost_state::Empty> {
3814 pub fn new() -> Self {
3816 ReasonRepostBuilder {
3817 _phantom_state: ::core::marker::PhantomData,
3818 __unsafe_private_named: (None, None, None, None),
3819 _phantom: ::core::marker::PhantomData,
3820 }
3821 }
3822}
3823
3824impl<'a, S> ReasonRepostBuilder<'a, S>
3825where
3826 S: reason_repost_state::State,
3827 S::By: reason_repost_state::IsUnset,
3828{
3829 pub fn by(
3831 mut self,
3832 value: impl Into<crate::app_bsky::actor::ProfileViewBasic<'a>>,
3833 ) -> ReasonRepostBuilder<'a, reason_repost_state::SetBy<S>> {
3834 self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
3835 ReasonRepostBuilder {
3836 _phantom_state: ::core::marker::PhantomData,
3837 __unsafe_private_named: self.__unsafe_private_named,
3838 _phantom: ::core::marker::PhantomData,
3839 }
3840 }
3841}
3842
3843impl<'a, S: reason_repost_state::State> ReasonRepostBuilder<'a, S> {
3844 pub fn cid(
3846 mut self,
3847 value: impl Into<Option<jacquard_common::types::string::Cid<'a>>>,
3848 ) -> Self {
3849 self.__unsafe_private_named.1 = value.into();
3850 self
3851 }
3852 pub fn maybe_cid(
3854 mut self,
3855 value: Option<jacquard_common::types::string::Cid<'a>>,
3856 ) -> Self {
3857 self.__unsafe_private_named.1 = value;
3858 self
3859 }
3860}
3861
3862impl<'a, S> ReasonRepostBuilder<'a, S>
3863where
3864 S: reason_repost_state::State,
3865 S::IndexedAt: reason_repost_state::IsUnset,
3866{
3867 pub fn indexed_at(
3869 mut self,
3870 value: impl Into<jacquard_common::types::string::Datetime>,
3871 ) -> ReasonRepostBuilder<'a, reason_repost_state::SetIndexedAt<S>> {
3872 self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into());
3873 ReasonRepostBuilder {
3874 _phantom_state: ::core::marker::PhantomData,
3875 __unsafe_private_named: self.__unsafe_private_named,
3876 _phantom: ::core::marker::PhantomData,
3877 }
3878 }
3879}
3880
3881impl<'a, S: reason_repost_state::State> ReasonRepostBuilder<'a, S> {
3882 pub fn uri(
3884 mut self,
3885 value: impl Into<Option<jacquard_common::types::string::AtUri<'a>>>,
3886 ) -> Self {
3887 self.__unsafe_private_named.3 = value.into();
3888 self
3889 }
3890 pub fn maybe_uri(
3892 mut self,
3893 value: Option<jacquard_common::types::string::AtUri<'a>>,
3894 ) -> Self {
3895 self.__unsafe_private_named.3 = value;
3896 self
3897 }
3898}
3899
3900impl<'a, S> ReasonRepostBuilder<'a, S>
3901where
3902 S: reason_repost_state::State,
3903 S::By: reason_repost_state::IsSet,
3904 S::IndexedAt: reason_repost_state::IsSet,
3905{
3906 pub fn build(self) -> ReasonRepost<'a> {
3908 ReasonRepost {
3909 by: self.__unsafe_private_named.0.unwrap(),
3910 cid: self.__unsafe_private_named.1,
3911 indexed_at: self.__unsafe_private_named.2.unwrap(),
3912 uri: self.__unsafe_private_named.3,
3913 extra_data: Default::default(),
3914 }
3915 }
3916 pub fn build_with_data(
3918 self,
3919 extra_data: std::collections::BTreeMap<
3920 jacquard_common::smol_str::SmolStr,
3921 jacquard_common::types::value::Data<'a>,
3922 >,
3923 ) -> ReasonRepost<'a> {
3924 ReasonRepost {
3925 by: self.__unsafe_private_named.0.unwrap(),
3926 cid: self.__unsafe_private_named.1,
3927 indexed_at: self.__unsafe_private_named.2.unwrap(),
3928 uri: self.__unsafe_private_named.3,
3929 extra_data: Some(extra_data),
3930 }
3931 }
3932}
3933
3934impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ReasonRepost<'a> {
3935 fn nsid() -> &'static str {
3936 "app.bsky.feed.defs"
3937 }
3938 fn def_name() -> &'static str {
3939 "reasonRepost"
3940 }
3941 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
3942 lexicon_doc_app_bsky_feed_defs()
3943 }
3944 fn validate(
3945 &self,
3946 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
3947 Ok(())
3948 }
3949}
3950
3951#[jacquard_derive::lexicon]
3952#[derive(
3953 serde::Serialize,
3954 serde::Deserialize,
3955 Debug,
3956 Clone,
3957 PartialEq,
3958 Eq,
3959 jacquard_derive::IntoStatic
3960)]
3961#[serde(rename_all = "camelCase")]
3962pub struct ReplyRef<'a> {
3963 #[serde(skip_serializing_if = "std::option::Option::is_none")]
3965 #[serde(borrow)]
3966 pub grandparent_author: Option<crate::app_bsky::actor::ProfileViewBasic<'a>>,
3967 #[serde(borrow)]
3968 pub parent: ReplyRefParent<'a>,
3969 #[serde(borrow)]
3970 pub root: ReplyRefRoot<'a>,
3971}
3972
3973pub mod reply_ref_state {
3974
3975 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
3976 #[allow(unused)]
3977 use ::core::marker::PhantomData;
3978 mod sealed {
3979 pub trait Sealed {}
3980 }
3981 pub trait State: sealed::Sealed {
3983 type Root;
3984 type Parent;
3985 }
3986 pub struct Empty(());
3988 impl sealed::Sealed for Empty {}
3989 impl State for Empty {
3990 type Root = Unset;
3991 type Parent = Unset;
3992 }
3993 pub struct SetRoot<S: State = Empty>(PhantomData<fn() -> S>);
3995 impl<S: State> sealed::Sealed for SetRoot<S> {}
3996 impl<S: State> State for SetRoot<S> {
3997 type Root = Set<members::root>;
3998 type Parent = S::Parent;
3999 }
4000 pub struct SetParent<S: State = Empty>(PhantomData<fn() -> S>);
4002 impl<S: State> sealed::Sealed for SetParent<S> {}
4003 impl<S: State> State for SetParent<S> {
4004 type Root = S::Root;
4005 type Parent = Set<members::parent>;
4006 }
4007 #[allow(non_camel_case_types)]
4009 pub mod members {
4010 pub struct root(());
4012 pub struct parent(());
4014 }
4015}
4016
4017pub struct ReplyRefBuilder<'a, S: reply_ref_state::State> {
4019 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
4020 __unsafe_private_named: (
4021 ::core::option::Option<crate::app_bsky::actor::ProfileViewBasic<'a>>,
4022 ::core::option::Option<ReplyRefParent<'a>>,
4023 ::core::option::Option<ReplyRefRoot<'a>>,
4024 ),
4025 _phantom: ::core::marker::PhantomData<&'a ()>,
4026}
4027
4028impl<'a> ReplyRef<'a> {
4029 pub fn new() -> ReplyRefBuilder<'a, reply_ref_state::Empty> {
4031 ReplyRefBuilder::new()
4032 }
4033}
4034
4035impl<'a> ReplyRefBuilder<'a, reply_ref_state::Empty> {
4036 pub fn new() -> Self {
4038 ReplyRefBuilder {
4039 _phantom_state: ::core::marker::PhantomData,
4040 __unsafe_private_named: (None, None, None),
4041 _phantom: ::core::marker::PhantomData,
4042 }
4043 }
4044}
4045
4046impl<'a, S: reply_ref_state::State> ReplyRefBuilder<'a, S> {
4047 pub fn grandparent_author(
4049 mut self,
4050 value: impl Into<Option<crate::app_bsky::actor::ProfileViewBasic<'a>>>,
4051 ) -> Self {
4052 self.__unsafe_private_named.0 = value.into();
4053 self
4054 }
4055 pub fn maybe_grandparent_author(
4057 mut self,
4058 value: Option<crate::app_bsky::actor::ProfileViewBasic<'a>>,
4059 ) -> Self {
4060 self.__unsafe_private_named.0 = value;
4061 self
4062 }
4063}
4064
4065impl<'a, S> ReplyRefBuilder<'a, S>
4066where
4067 S: reply_ref_state::State,
4068 S::Parent: reply_ref_state::IsUnset,
4069{
4070 pub fn parent(
4072 mut self,
4073 value: impl Into<ReplyRefParent<'a>>,
4074 ) -> ReplyRefBuilder<'a, reply_ref_state::SetParent<S>> {
4075 self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
4076 ReplyRefBuilder {
4077 _phantom_state: ::core::marker::PhantomData,
4078 __unsafe_private_named: self.__unsafe_private_named,
4079 _phantom: ::core::marker::PhantomData,
4080 }
4081 }
4082}
4083
4084impl<'a, S> ReplyRefBuilder<'a, S>
4085where
4086 S: reply_ref_state::State,
4087 S::Root: reply_ref_state::IsUnset,
4088{
4089 pub fn root(
4091 mut self,
4092 value: impl Into<ReplyRefRoot<'a>>,
4093 ) -> ReplyRefBuilder<'a, reply_ref_state::SetRoot<S>> {
4094 self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into());
4095 ReplyRefBuilder {
4096 _phantom_state: ::core::marker::PhantomData,
4097 __unsafe_private_named: self.__unsafe_private_named,
4098 _phantom: ::core::marker::PhantomData,
4099 }
4100 }
4101}
4102
4103impl<'a, S> ReplyRefBuilder<'a, S>
4104where
4105 S: reply_ref_state::State,
4106 S::Root: reply_ref_state::IsSet,
4107 S::Parent: reply_ref_state::IsSet,
4108{
4109 pub fn build(self) -> ReplyRef<'a> {
4111 ReplyRef {
4112 grandparent_author: self.__unsafe_private_named.0,
4113 parent: self.__unsafe_private_named.1.unwrap(),
4114 root: self.__unsafe_private_named.2.unwrap(),
4115 extra_data: Default::default(),
4116 }
4117 }
4118 pub fn build_with_data(
4120 self,
4121 extra_data: std::collections::BTreeMap<
4122 jacquard_common::smol_str::SmolStr,
4123 jacquard_common::types::value::Data<'a>,
4124 >,
4125 ) -> ReplyRef<'a> {
4126 ReplyRef {
4127 grandparent_author: self.__unsafe_private_named.0,
4128 parent: self.__unsafe_private_named.1.unwrap(),
4129 root: self.__unsafe_private_named.2.unwrap(),
4130 extra_data: Some(extra_data),
4131 }
4132 }
4133}
4134
4135#[jacquard_derive::open_union]
4136#[derive(
4137 serde::Serialize,
4138 serde::Deserialize,
4139 Debug,
4140 Clone,
4141 PartialEq,
4142 Eq,
4143 jacquard_derive::IntoStatic
4144)]
4145#[serde(tag = "$type")]
4146#[serde(bound(deserialize = "'de: 'a"))]
4147pub enum ReplyRefParent<'a> {
4148 #[serde(rename = "app.bsky.feed.defs#postView")]
4149 PostView(Box<crate::app_bsky::feed::PostView<'a>>),
4150 #[serde(rename = "app.bsky.feed.defs#notFoundPost")]
4151 NotFoundPost(Box<crate::app_bsky::feed::NotFoundPost<'a>>),
4152 #[serde(rename = "app.bsky.feed.defs#blockedPost")]
4153 BlockedPost(Box<crate::app_bsky::feed::BlockedPost<'a>>),
4154}
4155
4156#[jacquard_derive::open_union]
4157#[derive(
4158 serde::Serialize,
4159 serde::Deserialize,
4160 Debug,
4161 Clone,
4162 PartialEq,
4163 Eq,
4164 jacquard_derive::IntoStatic
4165)]
4166#[serde(tag = "$type")]
4167#[serde(bound(deserialize = "'de: 'a"))]
4168pub enum ReplyRefRoot<'a> {
4169 #[serde(rename = "app.bsky.feed.defs#postView")]
4170 PostView(Box<crate::app_bsky::feed::PostView<'a>>),
4171 #[serde(rename = "app.bsky.feed.defs#notFoundPost")]
4172 NotFoundPost(Box<crate::app_bsky::feed::NotFoundPost<'a>>),
4173 #[serde(rename = "app.bsky.feed.defs#blockedPost")]
4174 BlockedPost(Box<crate::app_bsky::feed::BlockedPost<'a>>),
4175}
4176
4177impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ReplyRef<'a> {
4178 fn nsid() -> &'static str {
4179 "app.bsky.feed.defs"
4180 }
4181 fn def_name() -> &'static str {
4182 "replyRef"
4183 }
4184 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
4185 lexicon_doc_app_bsky_feed_defs()
4186 }
4187 fn validate(
4188 &self,
4189 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
4190 Ok(())
4191 }
4192}
4193
4194#[derive(
4196 serde::Serialize,
4197 serde::Deserialize,
4198 Debug,
4199 Clone,
4200 PartialEq,
4201 Eq,
4202 Hash,
4203 jacquard_derive::IntoStatic
4204)]
4205pub struct RequestLess;
4206impl std::fmt::Display for RequestLess {
4207 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4208 write!(f, "requestLess")
4209 }
4210}
4211
4212#[derive(
4214 serde::Serialize,
4215 serde::Deserialize,
4216 Debug,
4217 Clone,
4218 PartialEq,
4219 Eq,
4220 Hash,
4221 jacquard_derive::IntoStatic
4222)]
4223pub struct RequestMore;
4224impl std::fmt::Display for RequestMore {
4225 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4226 write!(f, "requestMore")
4227 }
4228}
4229
4230#[jacquard_derive::lexicon]
4231#[derive(
4232 serde::Serialize,
4233 serde::Deserialize,
4234 Debug,
4235 Clone,
4236 PartialEq,
4237 Eq,
4238 jacquard_derive::IntoStatic
4239)]
4240#[serde(rename_all = "camelCase")]
4241pub struct SkeletonFeedPost<'a> {
4242 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4244 #[serde(borrow)]
4245 pub feed_context: Option<jacquard_common::CowStr<'a>>,
4246 #[serde(borrow)]
4247 pub post: jacquard_common::types::string::AtUri<'a>,
4248 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4249 #[serde(borrow)]
4250 pub reason: Option<SkeletonFeedPostReason<'a>>,
4251}
4252
4253pub mod skeleton_feed_post_state {
4254
4255 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
4256 #[allow(unused)]
4257 use ::core::marker::PhantomData;
4258 mod sealed {
4259 pub trait Sealed {}
4260 }
4261 pub trait State: sealed::Sealed {
4263 type Post;
4264 }
4265 pub struct Empty(());
4267 impl sealed::Sealed for Empty {}
4268 impl State for Empty {
4269 type Post = Unset;
4270 }
4271 pub struct SetPost<S: State = Empty>(PhantomData<fn() -> S>);
4273 impl<S: State> sealed::Sealed for SetPost<S> {}
4274 impl<S: State> State for SetPost<S> {
4275 type Post = Set<members::post>;
4276 }
4277 #[allow(non_camel_case_types)]
4279 pub mod members {
4280 pub struct post(());
4282 }
4283}
4284
4285pub struct SkeletonFeedPostBuilder<'a, S: skeleton_feed_post_state::State> {
4287 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
4288 __unsafe_private_named: (
4289 ::core::option::Option<jacquard_common::CowStr<'a>>,
4290 ::core::option::Option<jacquard_common::types::string::AtUri<'a>>,
4291 ::core::option::Option<SkeletonFeedPostReason<'a>>,
4292 ),
4293 _phantom: ::core::marker::PhantomData<&'a ()>,
4294}
4295
4296impl<'a> SkeletonFeedPost<'a> {
4297 pub fn new() -> SkeletonFeedPostBuilder<'a, skeleton_feed_post_state::Empty> {
4299 SkeletonFeedPostBuilder::new()
4300 }
4301}
4302
4303impl<'a> SkeletonFeedPostBuilder<'a, skeleton_feed_post_state::Empty> {
4304 pub fn new() -> Self {
4306 SkeletonFeedPostBuilder {
4307 _phantom_state: ::core::marker::PhantomData,
4308 __unsafe_private_named: (None, None, None),
4309 _phantom: ::core::marker::PhantomData,
4310 }
4311 }
4312}
4313
4314impl<'a, S: skeleton_feed_post_state::State> SkeletonFeedPostBuilder<'a, S> {
4315 pub fn feed_context(
4317 mut self,
4318 value: impl Into<Option<jacquard_common::CowStr<'a>>>,
4319 ) -> Self {
4320 self.__unsafe_private_named.0 = value.into();
4321 self
4322 }
4323 pub fn maybe_feed_context(
4325 mut self,
4326 value: Option<jacquard_common::CowStr<'a>>,
4327 ) -> Self {
4328 self.__unsafe_private_named.0 = value;
4329 self
4330 }
4331}
4332
4333impl<'a, S> SkeletonFeedPostBuilder<'a, S>
4334where
4335 S: skeleton_feed_post_state::State,
4336 S::Post: skeleton_feed_post_state::IsUnset,
4337{
4338 pub fn post(
4340 mut self,
4341 value: impl Into<jacquard_common::types::string::AtUri<'a>>,
4342 ) -> SkeletonFeedPostBuilder<'a, skeleton_feed_post_state::SetPost<S>> {
4343 self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
4344 SkeletonFeedPostBuilder {
4345 _phantom_state: ::core::marker::PhantomData,
4346 __unsafe_private_named: self.__unsafe_private_named,
4347 _phantom: ::core::marker::PhantomData,
4348 }
4349 }
4350}
4351
4352impl<'a, S: skeleton_feed_post_state::State> SkeletonFeedPostBuilder<'a, S> {
4353 pub fn reason(
4355 mut self,
4356 value: impl Into<Option<SkeletonFeedPostReason<'a>>>,
4357 ) -> Self {
4358 self.__unsafe_private_named.2 = value.into();
4359 self
4360 }
4361 pub fn maybe_reason(mut self, value: Option<SkeletonFeedPostReason<'a>>) -> Self {
4363 self.__unsafe_private_named.2 = value;
4364 self
4365 }
4366}
4367
4368impl<'a, S> SkeletonFeedPostBuilder<'a, S>
4369where
4370 S: skeleton_feed_post_state::State,
4371 S::Post: skeleton_feed_post_state::IsSet,
4372{
4373 pub fn build(self) -> SkeletonFeedPost<'a> {
4375 SkeletonFeedPost {
4376 feed_context: self.__unsafe_private_named.0,
4377 post: self.__unsafe_private_named.1.unwrap(),
4378 reason: self.__unsafe_private_named.2,
4379 extra_data: Default::default(),
4380 }
4381 }
4382 pub fn build_with_data(
4384 self,
4385 extra_data: std::collections::BTreeMap<
4386 jacquard_common::smol_str::SmolStr,
4387 jacquard_common::types::value::Data<'a>,
4388 >,
4389 ) -> SkeletonFeedPost<'a> {
4390 SkeletonFeedPost {
4391 feed_context: self.__unsafe_private_named.0,
4392 post: self.__unsafe_private_named.1.unwrap(),
4393 reason: self.__unsafe_private_named.2,
4394 extra_data: Some(extra_data),
4395 }
4396 }
4397}
4398
4399#[jacquard_derive::open_union]
4400#[derive(
4401 serde::Serialize,
4402 serde::Deserialize,
4403 Debug,
4404 Clone,
4405 PartialEq,
4406 Eq,
4407 jacquard_derive::IntoStatic
4408)]
4409#[serde(tag = "$type")]
4410#[serde(bound(deserialize = "'de: 'a"))]
4411pub enum SkeletonFeedPostReason<'a> {
4412 #[serde(rename = "app.bsky.feed.defs#skeletonReasonRepost")]
4413 SkeletonReasonRepost(Box<crate::app_bsky::feed::SkeletonReasonRepost<'a>>),
4414 #[serde(rename = "app.bsky.feed.defs#skeletonReasonPin")]
4415 SkeletonReasonPin(Box<crate::app_bsky::feed::SkeletonReasonPin<'a>>),
4416}
4417
4418impl<'a> ::jacquard_lexicon::schema::LexiconSchema for SkeletonFeedPost<'a> {
4419 fn nsid() -> &'static str {
4420 "app.bsky.feed.defs"
4421 }
4422 fn def_name() -> &'static str {
4423 "skeletonFeedPost"
4424 }
4425 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
4426 lexicon_doc_app_bsky_feed_defs()
4427 }
4428 fn validate(
4429 &self,
4430 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
4431 if let Some(ref value) = self.feed_context {
4432 #[allow(unused_comparisons)]
4433 if <str>::len(value.as_ref()) > 2000usize {
4434 return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
4435 path: ::jacquard_lexicon::validation::ValidationPath::from_field(
4436 "feed_context",
4437 ),
4438 max: 2000usize,
4439 actual: <str>::len(value.as_ref()),
4440 });
4441 }
4442 }
4443 Ok(())
4444 }
4445}
4446
4447#[jacquard_derive::lexicon]
4448#[derive(
4449 serde::Serialize,
4450 serde::Deserialize,
4451 Debug,
4452 Clone,
4453 PartialEq,
4454 Eq,
4455 jacquard_derive::IntoStatic,
4456 Default
4457)]
4458#[serde(rename_all = "camelCase")]
4459pub struct SkeletonReasonPin<'a> {}
4460impl<'a> ::jacquard_lexicon::schema::LexiconSchema for SkeletonReasonPin<'a> {
4461 fn nsid() -> &'static str {
4462 "app.bsky.feed.defs"
4463 }
4464 fn def_name() -> &'static str {
4465 "skeletonReasonPin"
4466 }
4467 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
4468 lexicon_doc_app_bsky_feed_defs()
4469 }
4470 fn validate(
4471 &self,
4472 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
4473 Ok(())
4474 }
4475}
4476
4477#[jacquard_derive::lexicon]
4478#[derive(
4479 serde::Serialize,
4480 serde::Deserialize,
4481 Debug,
4482 Clone,
4483 PartialEq,
4484 Eq,
4485 jacquard_derive::IntoStatic
4486)]
4487#[serde(rename_all = "camelCase")]
4488pub struct SkeletonReasonRepost<'a> {
4489 #[serde(borrow)]
4490 pub repost: jacquard_common::types::string::AtUri<'a>,
4491}
4492
4493pub mod skeleton_reason_repost_state {
4494
4495 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
4496 #[allow(unused)]
4497 use ::core::marker::PhantomData;
4498 mod sealed {
4499 pub trait Sealed {}
4500 }
4501 pub trait State: sealed::Sealed {
4503 type Repost;
4504 }
4505 pub struct Empty(());
4507 impl sealed::Sealed for Empty {}
4508 impl State for Empty {
4509 type Repost = Unset;
4510 }
4511 pub struct SetRepost<S: State = Empty>(PhantomData<fn() -> S>);
4513 impl<S: State> sealed::Sealed for SetRepost<S> {}
4514 impl<S: State> State for SetRepost<S> {
4515 type Repost = Set<members::repost>;
4516 }
4517 #[allow(non_camel_case_types)]
4519 pub mod members {
4520 pub struct repost(());
4522 }
4523}
4524
4525pub struct SkeletonReasonRepostBuilder<'a, S: skeleton_reason_repost_state::State> {
4527 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
4528 __unsafe_private_named: (
4529 ::core::option::Option<jacquard_common::types::string::AtUri<'a>>,
4530 ),
4531 _phantom: ::core::marker::PhantomData<&'a ()>,
4532}
4533
4534impl<'a> SkeletonReasonRepost<'a> {
4535 pub fn new() -> SkeletonReasonRepostBuilder<
4537 'a,
4538 skeleton_reason_repost_state::Empty,
4539 > {
4540 SkeletonReasonRepostBuilder::new()
4541 }
4542}
4543
4544impl<'a> SkeletonReasonRepostBuilder<'a, skeleton_reason_repost_state::Empty> {
4545 pub fn new() -> Self {
4547 SkeletonReasonRepostBuilder {
4548 _phantom_state: ::core::marker::PhantomData,
4549 __unsafe_private_named: (None,),
4550 _phantom: ::core::marker::PhantomData,
4551 }
4552 }
4553}
4554
4555impl<'a, S> SkeletonReasonRepostBuilder<'a, S>
4556where
4557 S: skeleton_reason_repost_state::State,
4558 S::Repost: skeleton_reason_repost_state::IsUnset,
4559{
4560 pub fn repost(
4562 mut self,
4563 value: impl Into<jacquard_common::types::string::AtUri<'a>>,
4564 ) -> SkeletonReasonRepostBuilder<'a, skeleton_reason_repost_state::SetRepost<S>> {
4565 self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
4566 SkeletonReasonRepostBuilder {
4567 _phantom_state: ::core::marker::PhantomData,
4568 __unsafe_private_named: self.__unsafe_private_named,
4569 _phantom: ::core::marker::PhantomData,
4570 }
4571 }
4572}
4573
4574impl<'a, S> SkeletonReasonRepostBuilder<'a, S>
4575where
4576 S: skeleton_reason_repost_state::State,
4577 S::Repost: skeleton_reason_repost_state::IsSet,
4578{
4579 pub fn build(self) -> SkeletonReasonRepost<'a> {
4581 SkeletonReasonRepost {
4582 repost: self.__unsafe_private_named.0.unwrap(),
4583 extra_data: Default::default(),
4584 }
4585 }
4586 pub fn build_with_data(
4588 self,
4589 extra_data: std::collections::BTreeMap<
4590 jacquard_common::smol_str::SmolStr,
4591 jacquard_common::types::value::Data<'a>,
4592 >,
4593 ) -> SkeletonReasonRepost<'a> {
4594 SkeletonReasonRepost {
4595 repost: self.__unsafe_private_named.0.unwrap(),
4596 extra_data: Some(extra_data),
4597 }
4598 }
4599}
4600
4601impl<'a> ::jacquard_lexicon::schema::LexiconSchema for SkeletonReasonRepost<'a> {
4602 fn nsid() -> &'static str {
4603 "app.bsky.feed.defs"
4604 }
4605 fn def_name() -> &'static str {
4606 "skeletonReasonRepost"
4607 }
4608 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
4609 lexicon_doc_app_bsky_feed_defs()
4610 }
4611 fn validate(
4612 &self,
4613 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
4614 Ok(())
4615 }
4616}
4617
4618#[jacquard_derive::lexicon]
4620#[derive(
4621 serde::Serialize,
4622 serde::Deserialize,
4623 Debug,
4624 Clone,
4625 PartialEq,
4626 Eq,
4627 jacquard_derive::IntoStatic,
4628 Default
4629)]
4630#[serde(rename_all = "camelCase")]
4631pub struct ThreadContext<'a> {
4632 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4633 #[serde(borrow)]
4634 pub root_author_like: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
4635}
4636
4637impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ThreadContext<'a> {
4638 fn nsid() -> &'static str {
4639 "app.bsky.feed.defs"
4640 }
4641 fn def_name() -> &'static str {
4642 "threadContext"
4643 }
4644 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
4645 lexicon_doc_app_bsky_feed_defs()
4646 }
4647 fn validate(
4648 &self,
4649 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
4650 Ok(())
4651 }
4652}
4653
4654#[jacquard_derive::lexicon]
4655#[derive(
4656 serde::Serialize,
4657 serde::Deserialize,
4658 Debug,
4659 Clone,
4660 PartialEq,
4661 Eq,
4662 jacquard_derive::IntoStatic
4663)]
4664#[serde(rename_all = "camelCase")]
4665pub struct ThreadViewPost<'a> {
4666 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4667 #[serde(borrow)]
4668 pub parent: Option<ThreadViewPostParent<'a>>,
4669 #[serde(borrow)]
4670 pub post: crate::app_bsky::feed::PostView<'a>,
4671 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4672 #[serde(borrow)]
4673 pub replies: Option<Vec<ThreadViewPostRepliesItem<'a>>>,
4674 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4675 #[serde(borrow)]
4676 pub thread_context: Option<crate::app_bsky::feed::ThreadContext<'a>>,
4677}
4678
4679pub mod thread_view_post_state {
4680
4681 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
4682 #[allow(unused)]
4683 use ::core::marker::PhantomData;
4684 mod sealed {
4685 pub trait Sealed {}
4686 }
4687 pub trait State: sealed::Sealed {
4689 type Post;
4690 }
4691 pub struct Empty(());
4693 impl sealed::Sealed for Empty {}
4694 impl State for Empty {
4695 type Post = Unset;
4696 }
4697 pub struct SetPost<S: State = Empty>(PhantomData<fn() -> S>);
4699 impl<S: State> sealed::Sealed for SetPost<S> {}
4700 impl<S: State> State for SetPost<S> {
4701 type Post = Set<members::post>;
4702 }
4703 #[allow(non_camel_case_types)]
4705 pub mod members {
4706 pub struct post(());
4708 }
4709}
4710
4711pub struct ThreadViewPostBuilder<'a, S: thread_view_post_state::State> {
4713 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
4714 __unsafe_private_named: (
4715 ::core::option::Option<ThreadViewPostParent<'a>>,
4716 ::core::option::Option<crate::app_bsky::feed::PostView<'a>>,
4717 ::core::option::Option<Vec<ThreadViewPostRepliesItem<'a>>>,
4718 ::core::option::Option<crate::app_bsky::feed::ThreadContext<'a>>,
4719 ),
4720 _phantom: ::core::marker::PhantomData<&'a ()>,
4721}
4722
4723impl<'a> ThreadViewPost<'a> {
4724 pub fn new() -> ThreadViewPostBuilder<'a, thread_view_post_state::Empty> {
4726 ThreadViewPostBuilder::new()
4727 }
4728}
4729
4730impl<'a> ThreadViewPostBuilder<'a, thread_view_post_state::Empty> {
4731 pub fn new() -> Self {
4733 ThreadViewPostBuilder {
4734 _phantom_state: ::core::marker::PhantomData,
4735 __unsafe_private_named: (None, None, None, None),
4736 _phantom: ::core::marker::PhantomData,
4737 }
4738 }
4739}
4740
4741impl<'a, S: thread_view_post_state::State> ThreadViewPostBuilder<'a, S> {
4742 pub fn parent(mut self, value: impl Into<Option<ThreadViewPostParent<'a>>>) -> Self {
4744 self.__unsafe_private_named.0 = value.into();
4745 self
4746 }
4747 pub fn maybe_parent(mut self, value: Option<ThreadViewPostParent<'a>>) -> Self {
4749 self.__unsafe_private_named.0 = value;
4750 self
4751 }
4752}
4753
4754impl<'a, S> ThreadViewPostBuilder<'a, S>
4755where
4756 S: thread_view_post_state::State,
4757 S::Post: thread_view_post_state::IsUnset,
4758{
4759 pub fn post(
4761 mut self,
4762 value: impl Into<crate::app_bsky::feed::PostView<'a>>,
4763 ) -> ThreadViewPostBuilder<'a, thread_view_post_state::SetPost<S>> {
4764 self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
4765 ThreadViewPostBuilder {
4766 _phantom_state: ::core::marker::PhantomData,
4767 __unsafe_private_named: self.__unsafe_private_named,
4768 _phantom: ::core::marker::PhantomData,
4769 }
4770 }
4771}
4772
4773impl<'a, S: thread_view_post_state::State> ThreadViewPostBuilder<'a, S> {
4774 pub fn replies(
4776 mut self,
4777 value: impl Into<Option<Vec<ThreadViewPostRepliesItem<'a>>>>,
4778 ) -> Self {
4779 self.__unsafe_private_named.2 = value.into();
4780 self
4781 }
4782 pub fn maybe_replies(
4784 mut self,
4785 value: Option<Vec<ThreadViewPostRepliesItem<'a>>>,
4786 ) -> Self {
4787 self.__unsafe_private_named.2 = value;
4788 self
4789 }
4790}
4791
4792impl<'a, S: thread_view_post_state::State> ThreadViewPostBuilder<'a, S> {
4793 pub fn thread_context(
4795 mut self,
4796 value: impl Into<Option<crate::app_bsky::feed::ThreadContext<'a>>>,
4797 ) -> Self {
4798 self.__unsafe_private_named.3 = value.into();
4799 self
4800 }
4801 pub fn maybe_thread_context(
4803 mut self,
4804 value: Option<crate::app_bsky::feed::ThreadContext<'a>>,
4805 ) -> Self {
4806 self.__unsafe_private_named.3 = value;
4807 self
4808 }
4809}
4810
4811impl<'a, S> ThreadViewPostBuilder<'a, S>
4812where
4813 S: thread_view_post_state::State,
4814 S::Post: thread_view_post_state::IsSet,
4815{
4816 pub fn build(self) -> ThreadViewPost<'a> {
4818 ThreadViewPost {
4819 parent: self.__unsafe_private_named.0,
4820 post: self.__unsafe_private_named.1.unwrap(),
4821 replies: self.__unsafe_private_named.2,
4822 thread_context: self.__unsafe_private_named.3,
4823 extra_data: Default::default(),
4824 }
4825 }
4826 pub fn build_with_data(
4828 self,
4829 extra_data: std::collections::BTreeMap<
4830 jacquard_common::smol_str::SmolStr,
4831 jacquard_common::types::value::Data<'a>,
4832 >,
4833 ) -> ThreadViewPost<'a> {
4834 ThreadViewPost {
4835 parent: self.__unsafe_private_named.0,
4836 post: self.__unsafe_private_named.1.unwrap(),
4837 replies: self.__unsafe_private_named.2,
4838 thread_context: self.__unsafe_private_named.3,
4839 extra_data: Some(extra_data),
4840 }
4841 }
4842}
4843
4844#[jacquard_derive::open_union]
4845#[derive(
4846 serde::Serialize,
4847 serde::Deserialize,
4848 Debug,
4849 Clone,
4850 PartialEq,
4851 Eq,
4852 jacquard_derive::IntoStatic
4853)]
4854#[serde(tag = "$type")]
4855#[serde(bound(deserialize = "'de: 'a"))]
4856pub enum ThreadViewPostParent<'a> {
4857 #[serde(rename = "app.bsky.feed.defs#threadViewPost")]
4858 ThreadViewPost(Box<crate::app_bsky::feed::ThreadViewPost<'a>>),
4859 #[serde(rename = "app.bsky.feed.defs#notFoundPost")]
4860 NotFoundPost(Box<crate::app_bsky::feed::NotFoundPost<'a>>),
4861 #[serde(rename = "app.bsky.feed.defs#blockedPost")]
4862 BlockedPost(Box<crate::app_bsky::feed::BlockedPost<'a>>),
4863}
4864
4865#[jacquard_derive::open_union]
4866#[derive(
4867 serde::Serialize,
4868 serde::Deserialize,
4869 Debug,
4870 Clone,
4871 PartialEq,
4872 Eq,
4873 jacquard_derive::IntoStatic
4874)]
4875#[serde(tag = "$type")]
4876#[serde(bound(deserialize = "'de: 'a"))]
4877pub enum ThreadViewPostRepliesItem<'a> {
4878 #[serde(rename = "app.bsky.feed.defs#threadViewPost")]
4879 ThreadViewPost(Box<crate::app_bsky::feed::ThreadViewPost<'a>>),
4880 #[serde(rename = "app.bsky.feed.defs#notFoundPost")]
4881 NotFoundPost(Box<crate::app_bsky::feed::NotFoundPost<'a>>),
4882 #[serde(rename = "app.bsky.feed.defs#blockedPost")]
4883 BlockedPost(Box<crate::app_bsky::feed::BlockedPost<'a>>),
4884}
4885
4886impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ThreadViewPost<'a> {
4887 fn nsid() -> &'static str {
4888 "app.bsky.feed.defs"
4889 }
4890 fn def_name() -> &'static str {
4891 "threadViewPost"
4892 }
4893 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
4894 lexicon_doc_app_bsky_feed_defs()
4895 }
4896 fn validate(
4897 &self,
4898 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
4899 Ok(())
4900 }
4901}
4902
4903#[jacquard_derive::lexicon]
4904#[derive(
4905 serde::Serialize,
4906 serde::Deserialize,
4907 Debug,
4908 Clone,
4909 PartialEq,
4910 Eq,
4911 jacquard_derive::IntoStatic,
4912 Default
4913)]
4914#[serde(rename_all = "camelCase")]
4915pub struct ThreadgateView<'a> {
4916 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4917 #[serde(borrow)]
4918 pub cid: std::option::Option<jacquard_common::types::string::Cid<'a>>,
4919 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4920 #[serde(borrow)]
4921 pub lists: std::option::Option<Vec<crate::app_bsky::graph::ListViewBasic<'a>>>,
4922 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4923 #[serde(borrow)]
4924 pub record: std::option::Option<jacquard_common::types::value::Data<'a>>,
4925 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4926 #[serde(borrow)]
4927 pub uri: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
4928}
4929
4930impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ThreadgateView<'a> {
4931 fn nsid() -> &'static str {
4932 "app.bsky.feed.defs"
4933 }
4934 fn def_name() -> &'static str {
4935 "threadgateView"
4936 }
4937 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
4938 lexicon_doc_app_bsky_feed_defs()
4939 }
4940 fn validate(
4941 &self,
4942 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
4943 Ok(())
4944 }
4945}
4946
4947#[jacquard_derive::lexicon]
4949#[derive(
4950 serde::Serialize,
4951 serde::Deserialize,
4952 Debug,
4953 Clone,
4954 PartialEq,
4955 Eq,
4956 jacquard_derive::IntoStatic,
4957 Default
4958)]
4959#[serde(rename_all = "camelCase")]
4960pub struct ViewerState<'a> {
4961 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4962 pub bookmarked: std::option::Option<bool>,
4963 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4964 pub embedding_disabled: std::option::Option<bool>,
4965 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4966 #[serde(borrow)]
4967 pub like: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
4968 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4969 pub pinned: std::option::Option<bool>,
4970 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4971 pub reply_disabled: std::option::Option<bool>,
4972 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4973 #[serde(borrow)]
4974 pub repost: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
4975 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4976 pub thread_muted: std::option::Option<bool>,
4977}
4978
4979impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ViewerState<'a> {
4980 fn nsid() -> &'static str {
4981 "app.bsky.feed.defs"
4982 }
4983 fn def_name() -> &'static str {
4984 "viewerState"
4985 }
4986 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
4987 lexicon_doc_app_bsky_feed_defs()
4988 }
4989 fn validate(
4990 &self,
4991 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
4992 Ok(())
4993 }
4994}