1pub mod get_preferences;
9pub mod get_profile;
10pub mod get_profiles;
11pub mod get_suggestions;
12pub mod profile;
13pub mod put_preferences;
14pub mod search_actors;
15pub mod search_actors_typeahead;
16pub mod status;
17
18#[jacquard_derive::lexicon]
19#[derive(
20 serde::Serialize,
21 serde::Deserialize,
22 Debug,
23 Clone,
24 PartialEq,
25 Eq,
26 jacquard_derive::IntoStatic
27)]
28#[serde(rename_all = "camelCase")]
29pub struct AdultContentPref<'a> {
30 pub enabled: bool,
31}
32
33pub mod adult_content_pref_state {
34
35 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
36 #[allow(unused)]
37 use ::core::marker::PhantomData;
38 mod sealed {
39 pub trait Sealed {}
40 }
41 pub trait State: sealed::Sealed {
43 type Enabled;
44 }
45 pub struct Empty(());
47 impl sealed::Sealed for Empty {}
48 impl State for Empty {
49 type Enabled = Unset;
50 }
51 pub struct SetEnabled<S: State = Empty>(PhantomData<fn() -> S>);
53 impl<S: State> sealed::Sealed for SetEnabled<S> {}
54 impl<S: State> State for SetEnabled<S> {
55 type Enabled = Set<members::enabled>;
56 }
57 #[allow(non_camel_case_types)]
59 pub mod members {
60 pub struct enabled(());
62 }
63}
64
65pub struct AdultContentPrefBuilder<'a, S: adult_content_pref_state::State> {
67 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
68 __unsafe_private_named: (::core::option::Option<bool>,),
69 _phantom: ::core::marker::PhantomData<&'a ()>,
70}
71
72impl<'a> AdultContentPref<'a> {
73 pub fn new() -> AdultContentPrefBuilder<'a, adult_content_pref_state::Empty> {
75 AdultContentPrefBuilder::new()
76 }
77}
78
79impl<'a> AdultContentPrefBuilder<'a, adult_content_pref_state::Empty> {
80 pub fn new() -> Self {
82 AdultContentPrefBuilder {
83 _phantom_state: ::core::marker::PhantomData,
84 __unsafe_private_named: (None,),
85 _phantom: ::core::marker::PhantomData,
86 }
87 }
88}
89
90impl<'a, S> AdultContentPrefBuilder<'a, S>
91where
92 S: adult_content_pref_state::State,
93 S::Enabled: adult_content_pref_state::IsUnset,
94{
95 pub fn enabled(
97 mut self,
98 value: impl Into<bool>,
99 ) -> AdultContentPrefBuilder<'a, adult_content_pref_state::SetEnabled<S>> {
100 self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
101 AdultContentPrefBuilder {
102 _phantom_state: ::core::marker::PhantomData,
103 __unsafe_private_named: self.__unsafe_private_named,
104 _phantom: ::core::marker::PhantomData,
105 }
106 }
107}
108
109impl<'a, S> AdultContentPrefBuilder<'a, S>
110where
111 S: adult_content_pref_state::State,
112 S::Enabled: adult_content_pref_state::IsSet,
113{
114 pub fn build(self) -> AdultContentPref<'a> {
116 AdultContentPref {
117 enabled: self.__unsafe_private_named.0.unwrap(),
118 extra_data: Default::default(),
119 }
120 }
121 pub fn build_with_data(
123 self,
124 extra_data: std::collections::BTreeMap<
125 jacquard_common::smol_str::SmolStr,
126 jacquard_common::types::value::Data<'a>,
127 >,
128 ) -> AdultContentPref<'a> {
129 AdultContentPref {
130 enabled: self.__unsafe_private_named.0.unwrap(),
131 extra_data: Some(extra_data),
132 }
133 }
134}
135
136fn lexicon_doc_app_bsky_actor_defs() -> ::jacquard_lexicon::lexicon::LexiconDoc<
137 'static,
138> {
139 ::jacquard_lexicon::lexicon::LexiconDoc {
140 lexicon: ::jacquard_lexicon::lexicon::Lexicon::Lexicon1,
141 id: ::jacquard_common::CowStr::new_static("app.bsky.actor.defs"),
142 revision: None,
143 description: None,
144 defs: {
145 let mut map = ::std::collections::BTreeMap::new();
146 map.insert(
147 ::jacquard_common::smol_str::SmolStr::new_static("adultContentPref"),
148 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
149 description: None,
150 required: Some(
151 vec![::jacquard_common::smol_str::SmolStr::new_static("enabled")],
152 ),
153 nullable: None,
154 properties: {
155 #[allow(unused_mut)]
156 let mut map = ::std::collections::BTreeMap::new();
157 map.insert(
158 ::jacquard_common::smol_str::SmolStr::new_static("enabled"),
159 ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
160 description: None,
161 default: None,
162 r#const: None,
163 }),
164 );
165 map
166 },
167 }),
168 );
169 map.insert(
170 ::jacquard_common::smol_str::SmolStr::new_static("bskyAppProgressGuide"),
171 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
172 description: Some(
173 ::jacquard_common::CowStr::new_static(
174 "If set, an active progress guide. Once completed, can be set to undefined. Should have unspecced fields tracking progress.",
175 ),
176 ),
177 required: Some(
178 vec![::jacquard_common::smol_str::SmolStr::new_static("guide")],
179 ),
180 nullable: None,
181 properties: {
182 #[allow(unused_mut)]
183 let mut map = ::std::collections::BTreeMap::new();
184 map.insert(
185 ::jacquard_common::smol_str::SmolStr::new_static("guide"),
186 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
187 description: None,
188 format: None,
189 default: None,
190 min_length: None,
191 max_length: Some(100usize),
192 min_graphemes: None,
193 max_graphemes: None,
194 r#enum: None,
195 r#const: None,
196 known_values: None,
197 }),
198 );
199 map
200 },
201 }),
202 );
203 map.insert(
204 ::jacquard_common::smol_str::SmolStr::new_static("bskyAppStatePref"),
205 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
206 description: Some(
207 ::jacquard_common::CowStr::new_static(
208 "A grab bag of state that's specific to the bsky.app program. Third-party apps shouldn't use this.",
209 ),
210 ),
211 required: None,
212 nullable: None,
213 properties: {
214 #[allow(unused_mut)]
215 let mut map = ::std::collections::BTreeMap::new();
216 map.insert(
217 ::jacquard_common::smol_str::SmolStr::new_static(
218 "activeProgressGuide",
219 ),
220 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
221 description: None,
222 r#ref: ::jacquard_common::CowStr::new_static(
223 "#bskyAppProgressGuide",
224 ),
225 }),
226 );
227 map.insert(
228 ::jacquard_common::smol_str::SmolStr::new_static("nuxs"),
229 ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
230 description: Some(
231 ::jacquard_common::CowStr::new_static(
232 "Storage for NUXs the user has encountered.",
233 ),
234 ),
235 items: ::jacquard_lexicon::lexicon::LexArrayItem::Ref(::jacquard_lexicon::lexicon::LexRef {
236 description: None,
237 r#ref: ::jacquard_common::CowStr::new_static(
238 "app.bsky.actor.defs#nux",
239 ),
240 }),
241 min_length: None,
242 max_length: Some(100usize),
243 }),
244 );
245 map.insert(
246 ::jacquard_common::smol_str::SmolStr::new_static(
247 "queuedNudges",
248 ),
249 ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
250 description: Some(
251 ::jacquard_common::CowStr::new_static(
252 "An array of tokens which identify nudges (modals, popups, tours, highlight dots) that should be shown to the user.",
253 ),
254 ),
255 items: ::jacquard_lexicon::lexicon::LexArrayItem::String(::jacquard_lexicon::lexicon::LexString {
256 description: None,
257 format: None,
258 default: None,
259 min_length: None,
260 max_length: Some(100usize),
261 min_graphemes: None,
262 max_graphemes: None,
263 r#enum: None,
264 r#const: None,
265 known_values: None,
266 }),
267 min_length: None,
268 max_length: Some(1000usize),
269 }),
270 );
271 map
272 },
273 }),
274 );
275 map.insert(
276 ::jacquard_common::smol_str::SmolStr::new_static("contentLabelPref"),
277 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
278 description: None,
279 required: Some(
280 vec![
281 ::jacquard_common::smol_str::SmolStr::new_static("label"),
282 ::jacquard_common::smol_str::SmolStr::new_static("visibility")
283 ],
284 ),
285 nullable: None,
286 properties: {
287 #[allow(unused_mut)]
288 let mut map = ::std::collections::BTreeMap::new();
289 map.insert(
290 ::jacquard_common::smol_str::SmolStr::new_static("label"),
291 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
292 description: None,
293 format: None,
294 default: None,
295 min_length: None,
296 max_length: None,
297 min_graphemes: None,
298 max_graphemes: None,
299 r#enum: None,
300 r#const: None,
301 known_values: None,
302 }),
303 );
304 map.insert(
305 ::jacquard_common::smol_str::SmolStr::new_static(
306 "labelerDid",
307 ),
308 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
309 description: Some(
310 ::jacquard_common::CowStr::new_static(
311 "Which labeler does this preference apply to? If undefined, applies globally.",
312 ),
313 ),
314 format: Some(
315 ::jacquard_lexicon::lexicon::LexStringFormat::Did,
316 ),
317 default: None,
318 min_length: None,
319 max_length: None,
320 min_graphemes: None,
321 max_graphemes: None,
322 r#enum: None,
323 r#const: None,
324 known_values: None,
325 }),
326 );
327 map.insert(
328 ::jacquard_common::smol_str::SmolStr::new_static(
329 "visibility",
330 ),
331 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
332 description: None,
333 format: None,
334 default: None,
335 min_length: None,
336 max_length: None,
337 min_graphemes: None,
338 max_graphemes: None,
339 r#enum: None,
340 r#const: None,
341 known_values: None,
342 }),
343 );
344 map
345 },
346 }),
347 );
348 map.insert(
349 ::jacquard_common::smol_str::SmolStr::new_static("feedViewPref"),
350 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
351 description: None,
352 required: Some(
353 vec![::jacquard_common::smol_str::SmolStr::new_static("feed")],
354 ),
355 nullable: None,
356 properties: {
357 #[allow(unused_mut)]
358 let mut map = ::std::collections::BTreeMap::new();
359 map.insert(
360 ::jacquard_common::smol_str::SmolStr::new_static("feed"),
361 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
362 description: Some(
363 ::jacquard_common::CowStr::new_static(
364 "The URI of the feed, or an identifier which describes the feed.",
365 ),
366 ),
367 format: None,
368 default: None,
369 min_length: None,
370 max_length: None,
371 min_graphemes: None,
372 max_graphemes: None,
373 r#enum: None,
374 r#const: None,
375 known_values: None,
376 }),
377 );
378 map.insert(
379 ::jacquard_common::smol_str::SmolStr::new_static(
380 "hideQuotePosts",
381 ),
382 ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
383 description: None,
384 default: None,
385 r#const: None,
386 }),
387 );
388 map.insert(
389 ::jacquard_common::smol_str::SmolStr::new_static(
390 "hideReplies",
391 ),
392 ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
393 description: None,
394 default: None,
395 r#const: None,
396 }),
397 );
398 map.insert(
399 ::jacquard_common::smol_str::SmolStr::new_static(
400 "hideRepliesByLikeCount",
401 ),
402 ::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger {
403 description: None,
404 default: None,
405 minimum: None,
406 maximum: None,
407 r#enum: None,
408 r#const: None,
409 }),
410 );
411 map.insert(
412 ::jacquard_common::smol_str::SmolStr::new_static(
413 "hideRepliesByUnfollowed",
414 ),
415 ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
416 description: None,
417 default: None,
418 r#const: None,
419 }),
420 );
421 map.insert(
422 ::jacquard_common::smol_str::SmolStr::new_static(
423 "hideReposts",
424 ),
425 ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
426 description: None,
427 default: None,
428 r#const: None,
429 }),
430 );
431 map
432 },
433 }),
434 );
435 map.insert(
436 ::jacquard_common::smol_str::SmolStr::new_static("hiddenPostsPref"),
437 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
438 description: None,
439 required: Some(
440 vec![::jacquard_common::smol_str::SmolStr::new_static("items")],
441 ),
442 nullable: None,
443 properties: {
444 #[allow(unused_mut)]
445 let mut map = ::std::collections::BTreeMap::new();
446 map.insert(
447 ::jacquard_common::smol_str::SmolStr::new_static("items"),
448 ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
449 description: Some(
450 ::jacquard_common::CowStr::new_static(
451 "A list of URIs of posts the account owner has hidden.",
452 ),
453 ),
454 items: ::jacquard_lexicon::lexicon::LexArrayItem::String(::jacquard_lexicon::lexicon::LexString {
455 description: None,
456 format: Some(
457 ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
458 ),
459 default: None,
460 min_length: None,
461 max_length: None,
462 min_graphemes: None,
463 max_graphemes: None,
464 r#enum: None,
465 r#const: None,
466 known_values: None,
467 }),
468 min_length: None,
469 max_length: None,
470 }),
471 );
472 map
473 },
474 }),
475 );
476 map.insert(
477 ::jacquard_common::smol_str::SmolStr::new_static("interestsPref"),
478 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
479 description: None,
480 required: Some(
481 vec![::jacquard_common::smol_str::SmolStr::new_static("tags")],
482 ),
483 nullable: None,
484 properties: {
485 #[allow(unused_mut)]
486 let mut map = ::std::collections::BTreeMap::new();
487 map.insert(
488 ::jacquard_common::smol_str::SmolStr::new_static("tags"),
489 ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
490 description: Some(
491 ::jacquard_common::CowStr::new_static(
492 "A list of tags which describe the account owner's interests gathered during onboarding.",
493 ),
494 ),
495 items: ::jacquard_lexicon::lexicon::LexArrayItem::String(::jacquard_lexicon::lexicon::LexString {
496 description: None,
497 format: None,
498 default: None,
499 min_length: None,
500 max_length: Some(640usize),
501 min_graphemes: None,
502 max_graphemes: Some(64usize),
503 r#enum: None,
504 r#const: None,
505 known_values: None,
506 }),
507 min_length: None,
508 max_length: Some(100usize),
509 }),
510 );
511 map
512 },
513 }),
514 );
515 map.insert(
516 ::jacquard_common::smol_str::SmolStr::new_static("knownFollowers"),
517 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
518 description: Some(
519 ::jacquard_common::CowStr::new_static(
520 "The subject's followers whom you also follow",
521 ),
522 ),
523 required: Some(
524 vec![
525 ::jacquard_common::smol_str::SmolStr::new_static("count"),
526 ::jacquard_common::smol_str::SmolStr::new_static("followers")
527 ],
528 ),
529 nullable: None,
530 properties: {
531 #[allow(unused_mut)]
532 let mut map = ::std::collections::BTreeMap::new();
533 map.insert(
534 ::jacquard_common::smol_str::SmolStr::new_static("count"),
535 ::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger {
536 description: None,
537 default: None,
538 minimum: None,
539 maximum: None,
540 r#enum: None,
541 r#const: None,
542 }),
543 );
544 map.insert(
545 ::jacquard_common::smol_str::SmolStr::new_static(
546 "followers",
547 ),
548 ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
549 description: None,
550 items: ::jacquard_lexicon::lexicon::LexArrayItem::Ref(::jacquard_lexicon::lexicon::LexRef {
551 description: None,
552 r#ref: ::jacquard_common::CowStr::new_static(
553 "#profileViewBasic",
554 ),
555 }),
556 min_length: Some(0usize),
557 max_length: Some(5usize),
558 }),
559 );
560 map
561 },
562 }),
563 );
564 map.insert(
565 ::jacquard_common::smol_str::SmolStr::new_static("labelerPrefItem"),
566 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
567 description: None,
568 required: Some(
569 vec![::jacquard_common::smol_str::SmolStr::new_static("did")],
570 ),
571 nullable: None,
572 properties: {
573 #[allow(unused_mut)]
574 let mut map = ::std::collections::BTreeMap::new();
575 map.insert(
576 ::jacquard_common::smol_str::SmolStr::new_static("did"),
577 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
578 description: None,
579 format: Some(
580 ::jacquard_lexicon::lexicon::LexStringFormat::Did,
581 ),
582 default: None,
583 min_length: None,
584 max_length: None,
585 min_graphemes: None,
586 max_graphemes: None,
587 r#enum: None,
588 r#const: None,
589 known_values: None,
590 }),
591 );
592 map
593 },
594 }),
595 );
596 map.insert(
597 ::jacquard_common::smol_str::SmolStr::new_static("labelersPref"),
598 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
599 description: None,
600 required: Some(
601 vec![
602 ::jacquard_common::smol_str::SmolStr::new_static("labelers")
603 ],
604 ),
605 nullable: None,
606 properties: {
607 #[allow(unused_mut)]
608 let mut map = ::std::collections::BTreeMap::new();
609 map.insert(
610 ::jacquard_common::smol_str::SmolStr::new_static("labelers"),
611 ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
612 description: None,
613 items: ::jacquard_lexicon::lexicon::LexArrayItem::Ref(::jacquard_lexicon::lexicon::LexRef {
614 description: None,
615 r#ref: ::jacquard_common::CowStr::new_static(
616 "#labelerPrefItem",
617 ),
618 }),
619 min_length: None,
620 max_length: None,
621 }),
622 );
623 map
624 },
625 }),
626 );
627 map.insert(
628 ::jacquard_common::smol_str::SmolStr::new_static("mutedWord"),
629 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
630 description: Some(
631 ::jacquard_common::CowStr::new_static(
632 "A word that the account owner has muted.",
633 ),
634 ),
635 required: Some(
636 vec![
637 ::jacquard_common::smol_str::SmolStr::new_static("value"),
638 ::jacquard_common::smol_str::SmolStr::new_static("targets")
639 ],
640 ),
641 nullable: None,
642 properties: {
643 #[allow(unused_mut)]
644 let mut map = ::std::collections::BTreeMap::new();
645 map.insert(
646 ::jacquard_common::smol_str::SmolStr::new_static(
647 "actorTarget",
648 ),
649 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
650 description: Some(
651 ::jacquard_common::CowStr::new_static(
652 "Groups of users to apply the muted word to. If undefined, applies to all users.",
653 ),
654 ),
655 format: None,
656 default: None,
657 min_length: None,
658 max_length: None,
659 min_graphemes: None,
660 max_graphemes: None,
661 r#enum: None,
662 r#const: None,
663 known_values: None,
664 }),
665 );
666 map.insert(
667 ::jacquard_common::smol_str::SmolStr::new_static(
668 "expiresAt",
669 ),
670 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
671 description: Some(
672 ::jacquard_common::CowStr::new_static(
673 "The date and time at which the muted word will expire and no longer be applied.",
674 ),
675 ),
676 format: Some(
677 ::jacquard_lexicon::lexicon::LexStringFormat::Datetime,
678 ),
679 default: None,
680 min_length: None,
681 max_length: None,
682 min_graphemes: None,
683 max_graphemes: None,
684 r#enum: None,
685 r#const: None,
686 known_values: None,
687 }),
688 );
689 map.insert(
690 ::jacquard_common::smol_str::SmolStr::new_static("id"),
691 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
692 description: None,
693 format: None,
694 default: None,
695 min_length: None,
696 max_length: None,
697 min_graphemes: None,
698 max_graphemes: None,
699 r#enum: None,
700 r#const: None,
701 known_values: None,
702 }),
703 );
704 map.insert(
705 ::jacquard_common::smol_str::SmolStr::new_static("targets"),
706 ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
707 description: Some(
708 ::jacquard_common::CowStr::new_static(
709 "The intended targets of the muted word.",
710 ),
711 ),
712 items: ::jacquard_lexicon::lexicon::LexArrayItem::Ref(::jacquard_lexicon::lexicon::LexRef {
713 description: None,
714 r#ref: ::jacquard_common::CowStr::new_static(
715 "app.bsky.actor.defs#mutedWordTarget",
716 ),
717 }),
718 min_length: None,
719 max_length: None,
720 }),
721 );
722 map.insert(
723 ::jacquard_common::smol_str::SmolStr::new_static("value"),
724 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
725 description: Some(
726 ::jacquard_common::CowStr::new_static(
727 "The muted word itself.",
728 ),
729 ),
730 format: None,
731 default: None,
732 min_length: None,
733 max_length: Some(10000usize),
734 min_graphemes: None,
735 max_graphemes: Some(1000usize),
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("mutedWordTarget"),
747 ::jacquard_lexicon::lexicon::LexUserType::String(::jacquard_lexicon::lexicon::LexString {
748 description: None,
749 format: None,
750 default: None,
751 min_length: None,
752 max_length: Some(640usize),
753 min_graphemes: None,
754 max_graphemes: Some(64usize),
755 r#enum: None,
756 r#const: None,
757 known_values: None,
758 }),
759 );
760 map.insert(
761 ::jacquard_common::smol_str::SmolStr::new_static("mutedWordsPref"),
762 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
763 description: None,
764 required: Some(
765 vec![::jacquard_common::smol_str::SmolStr::new_static("items")],
766 ),
767 nullable: None,
768 properties: {
769 #[allow(unused_mut)]
770 let mut map = ::std::collections::BTreeMap::new();
771 map.insert(
772 ::jacquard_common::smol_str::SmolStr::new_static("items"),
773 ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
774 description: Some(
775 ::jacquard_common::CowStr::new_static(
776 "A list of words the account owner has muted.",
777 ),
778 ),
779 items: ::jacquard_lexicon::lexicon::LexArrayItem::Ref(::jacquard_lexicon::lexicon::LexRef {
780 description: None,
781 r#ref: ::jacquard_common::CowStr::new_static(
782 "app.bsky.actor.defs#mutedWord",
783 ),
784 }),
785 min_length: None,
786 max_length: None,
787 }),
788 );
789 map
790 },
791 }),
792 );
793 map.insert(
794 ::jacquard_common::smol_str::SmolStr::new_static("nux"),
795 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
796 description: Some(
797 ::jacquard_common::CowStr::new_static(
798 "A new user experiences (NUX) storage object",
799 ),
800 ),
801 required: Some(
802 vec![
803 ::jacquard_common::smol_str::SmolStr::new_static("id"),
804 ::jacquard_common::smol_str::SmolStr::new_static("completed")
805 ],
806 ),
807 nullable: None,
808 properties: {
809 #[allow(unused_mut)]
810 let mut map = ::std::collections::BTreeMap::new();
811 map.insert(
812 ::jacquard_common::smol_str::SmolStr::new_static(
813 "completed",
814 ),
815 ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
816 description: None,
817 default: None,
818 r#const: None,
819 }),
820 );
821 map.insert(
822 ::jacquard_common::smol_str::SmolStr::new_static("data"),
823 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
824 description: Some(
825 ::jacquard_common::CowStr::new_static(
826 "Arbitrary data for the NUX. The structure is defined by the NUX itself. Limited to 300 characters.",
827 ),
828 ),
829 format: None,
830 default: None,
831 min_length: None,
832 max_length: Some(3000usize),
833 min_graphemes: None,
834 max_graphemes: Some(300usize),
835 r#enum: None,
836 r#const: None,
837 known_values: None,
838 }),
839 );
840 map.insert(
841 ::jacquard_common::smol_str::SmolStr::new_static(
842 "expiresAt",
843 ),
844 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
845 description: Some(
846 ::jacquard_common::CowStr::new_static(
847 "The date and time at which the NUX will expire and should be considered completed.",
848 ),
849 ),
850 format: Some(
851 ::jacquard_lexicon::lexicon::LexStringFormat::Datetime,
852 ),
853 default: None,
854 min_length: None,
855 max_length: None,
856 min_graphemes: None,
857 max_graphemes: None,
858 r#enum: None,
859 r#const: None,
860 known_values: None,
861 }),
862 );
863 map.insert(
864 ::jacquard_common::smol_str::SmolStr::new_static("id"),
865 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
866 description: None,
867 format: None,
868 default: None,
869 min_length: None,
870 max_length: Some(100usize),
871 min_graphemes: None,
872 max_graphemes: None,
873 r#enum: None,
874 r#const: None,
875 known_values: None,
876 }),
877 );
878 map
879 },
880 }),
881 );
882 map.insert(
883 ::jacquard_common::smol_str::SmolStr::new_static("personalDetailsPref"),
884 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
885 description: None,
886 required: None,
887 nullable: None,
888 properties: {
889 #[allow(unused_mut)]
890 let mut map = ::std::collections::BTreeMap::new();
891 map.insert(
892 ::jacquard_common::smol_str::SmolStr::new_static(
893 "birthDate",
894 ),
895 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
896 description: Some(
897 ::jacquard_common::CowStr::new_static(
898 "The birth date of account owner.",
899 ),
900 ),
901 format: Some(
902 ::jacquard_lexicon::lexicon::LexStringFormat::Datetime,
903 ),
904 default: None,
905 min_length: None,
906 max_length: None,
907 min_graphemes: None,
908 max_graphemes: None,
909 r#enum: None,
910 r#const: None,
911 known_values: None,
912 }),
913 );
914 map
915 },
916 }),
917 );
918 map.insert(
919 ::jacquard_common::smol_str::SmolStr::new_static(
920 "postInteractionSettingsPref",
921 ),
922 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
923 description: Some(
924 ::jacquard_common::CowStr::new_static(
925 "Default post interaction settings for the account. These values should be applied as default values when creating new posts. These refs should mirror the threadgate and postgate records exactly.",
926 ),
927 ),
928 required: Some(vec![]),
929 nullable: None,
930 properties: {
931 #[allow(unused_mut)]
932 let mut map = ::std::collections::BTreeMap::new();
933 map.insert(
934 ::jacquard_common::smol_str::SmolStr::new_static(
935 "postgateEmbeddingRules",
936 ),
937 ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
938 description: Some(
939 ::jacquard_common::CowStr::new_static(
940 "Matches postgate record. List of rules defining who can embed this users posts. If value is an empty array or is undefined, no particular rules apply and anyone can embed.",
941 ),
942 ),
943 items: ::jacquard_lexicon::lexicon::LexArrayItem::Union(::jacquard_lexicon::lexicon::LexRefUnion {
944 description: None,
945 refs: vec![
946 ::jacquard_common::CowStr::new_static("app.bsky.feed.postgate#disableRule")
947 ],
948 closed: None,
949 }),
950 min_length: None,
951 max_length: Some(5usize),
952 }),
953 );
954 map.insert(
955 ::jacquard_common::smol_str::SmolStr::new_static(
956 "threadgateAllowRules",
957 ),
958 ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
959 description: Some(
960 ::jacquard_common::CowStr::new_static(
961 "Matches threadgate record. List of rules defining who can reply to this users posts. If value is an empty array, no one can reply. If value is undefined, anyone can reply.",
962 ),
963 ),
964 items: ::jacquard_lexicon::lexicon::LexArrayItem::Union(::jacquard_lexicon::lexicon::LexRefUnion {
965 description: None,
966 refs: vec![
967 ::jacquard_common::CowStr::new_static("app.bsky.feed.threadgate#mentionRule"),
968 ::jacquard_common::CowStr::new_static("app.bsky.feed.threadgate#followerRule"),
969 ::jacquard_common::CowStr::new_static("app.bsky.feed.threadgate#followingRule"),
970 ::jacquard_common::CowStr::new_static("app.bsky.feed.threadgate#listRule")
971 ],
972 closed: None,
973 }),
974 min_length: None,
975 max_length: Some(5usize),
976 }),
977 );
978 map
979 },
980 }),
981 );
982 map.insert(
983 ::jacquard_common::smol_str::SmolStr::new_static("preferences"),
984 ::jacquard_lexicon::lexicon::LexUserType::Array(::jacquard_lexicon::lexicon::LexArray {
985 description: None,
986 items: ::jacquard_lexicon::lexicon::LexArrayItem::Union(::jacquard_lexicon::lexicon::LexRefUnion {
987 description: None,
988 refs: vec![
989 ::jacquard_common::CowStr::new_static("#adultContentPref"),
990 ::jacquard_common::CowStr::new_static("#contentLabelPref"),
991 ::jacquard_common::CowStr::new_static("#savedFeedsPref"),
992 ::jacquard_common::CowStr::new_static("#savedFeedsPrefV2"),
993 ::jacquard_common::CowStr::new_static("#personalDetailsPref"),
994 ::jacquard_common::CowStr::new_static("#feedViewPref"),
995 ::jacquard_common::CowStr::new_static("#threadViewPref"),
996 ::jacquard_common::CowStr::new_static("#interestsPref"),
997 ::jacquard_common::CowStr::new_static("#mutedWordsPref"),
998 ::jacquard_common::CowStr::new_static("#hiddenPostsPref"),
999 ::jacquard_common::CowStr::new_static("#bskyAppStatePref"),
1000 ::jacquard_common::CowStr::new_static("#labelersPref"),
1001 ::jacquard_common::CowStr::new_static("#postInteractionSettingsPref"),
1002 ::jacquard_common::CowStr::new_static("#verificationPrefs")
1003 ],
1004 closed: None,
1005 }),
1006 min_length: None,
1007 max_length: None,
1008 }),
1009 );
1010 map.insert(
1011 ::jacquard_common::smol_str::SmolStr::new_static("profileAssociated"),
1012 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
1013 description: None,
1014 required: None,
1015 nullable: None,
1016 properties: {
1017 #[allow(unused_mut)]
1018 let mut map = ::std::collections::BTreeMap::new();
1019 map.insert(
1020 ::jacquard_common::smol_str::SmolStr::new_static(
1021 "activitySubscription",
1022 ),
1023 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
1024 description: None,
1025 r#ref: ::jacquard_common::CowStr::new_static(
1026 "#profileAssociatedActivitySubscription",
1027 ),
1028 }),
1029 );
1030 map.insert(
1031 ::jacquard_common::smol_str::SmolStr::new_static("chat"),
1032 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
1033 description: None,
1034 r#ref: ::jacquard_common::CowStr::new_static(
1035 "#profileAssociatedChat",
1036 ),
1037 }),
1038 );
1039 map.insert(
1040 ::jacquard_common::smol_str::SmolStr::new_static("feedgens"),
1041 ::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger {
1042 description: None,
1043 default: None,
1044 minimum: None,
1045 maximum: None,
1046 r#enum: None,
1047 r#const: None,
1048 }),
1049 );
1050 map.insert(
1051 ::jacquard_common::smol_str::SmolStr::new_static("labeler"),
1052 ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
1053 description: None,
1054 default: None,
1055 r#const: None,
1056 }),
1057 );
1058 map.insert(
1059 ::jacquard_common::smol_str::SmolStr::new_static("lists"),
1060 ::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger {
1061 description: None,
1062 default: None,
1063 minimum: None,
1064 maximum: None,
1065 r#enum: None,
1066 r#const: None,
1067 }),
1068 );
1069 map.insert(
1070 ::jacquard_common::smol_str::SmolStr::new_static(
1071 "starterPacks",
1072 ),
1073 ::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger {
1074 description: None,
1075 default: None,
1076 minimum: None,
1077 maximum: None,
1078 r#enum: None,
1079 r#const: None,
1080 }),
1081 );
1082 map
1083 },
1084 }),
1085 );
1086 map.insert(
1087 ::jacquard_common::smol_str::SmolStr::new_static(
1088 "profileAssociatedActivitySubscription",
1089 ),
1090 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
1091 description: None,
1092 required: Some(
1093 vec![
1094 ::jacquard_common::smol_str::SmolStr::new_static("allowSubscriptions")
1095 ],
1096 ),
1097 nullable: None,
1098 properties: {
1099 #[allow(unused_mut)]
1100 let mut map = ::std::collections::BTreeMap::new();
1101 map.insert(
1102 ::jacquard_common::smol_str::SmolStr::new_static(
1103 "allowSubscriptions",
1104 ),
1105 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1106 description: None,
1107 format: None,
1108 default: None,
1109 min_length: None,
1110 max_length: None,
1111 min_graphemes: None,
1112 max_graphemes: None,
1113 r#enum: None,
1114 r#const: None,
1115 known_values: None,
1116 }),
1117 );
1118 map
1119 },
1120 }),
1121 );
1122 map.insert(
1123 ::jacquard_common::smol_str::SmolStr::new_static(
1124 "profileAssociatedChat",
1125 ),
1126 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
1127 description: None,
1128 required: Some(
1129 vec![
1130 ::jacquard_common::smol_str::SmolStr::new_static("allowIncoming")
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 "allowIncoming",
1140 ),
1141 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1142 description: None,
1143 format: None,
1144 default: None,
1145 min_length: None,
1146 max_length: None,
1147 min_graphemes: None,
1148 max_graphemes: None,
1149 r#enum: None,
1150 r#const: None,
1151 known_values: None,
1152 }),
1153 );
1154 map
1155 },
1156 }),
1157 );
1158 map.insert(
1159 ::jacquard_common::smol_str::SmolStr::new_static("profileView"),
1160 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
1161 description: None,
1162 required: Some(
1163 vec![
1164 ::jacquard_common::smol_str::SmolStr::new_static("did"),
1165 ::jacquard_common::smol_str::SmolStr::new_static("handle")
1166 ],
1167 ),
1168 nullable: None,
1169 properties: {
1170 #[allow(unused_mut)]
1171 let mut map = ::std::collections::BTreeMap::new();
1172 map.insert(
1173 ::jacquard_common::smol_str::SmolStr::new_static(
1174 "associated",
1175 ),
1176 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
1177 description: None,
1178 r#ref: ::jacquard_common::CowStr::new_static(
1179 "#profileAssociated",
1180 ),
1181 }),
1182 );
1183 map.insert(
1184 ::jacquard_common::smol_str::SmolStr::new_static("avatar"),
1185 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1186 description: None,
1187 format: Some(
1188 ::jacquard_lexicon::lexicon::LexStringFormat::Uri,
1189 ),
1190 default: None,
1191 min_length: None,
1192 max_length: None,
1193 min_graphemes: None,
1194 max_graphemes: None,
1195 r#enum: None,
1196 r#const: None,
1197 known_values: None,
1198 }),
1199 );
1200 map.insert(
1201 ::jacquard_common::smol_str::SmolStr::new_static(
1202 "createdAt",
1203 ),
1204 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1205 description: None,
1206 format: Some(
1207 ::jacquard_lexicon::lexicon::LexStringFormat::Datetime,
1208 ),
1209 default: None,
1210 min_length: None,
1211 max_length: None,
1212 min_graphemes: None,
1213 max_graphemes: None,
1214 r#enum: None,
1215 r#const: None,
1216 known_values: None,
1217 }),
1218 );
1219 map.insert(
1220 ::jacquard_common::smol_str::SmolStr::new_static("debug"),
1221 ::jacquard_lexicon::lexicon::LexObjectProperty::Unknown(::jacquard_lexicon::lexicon::LexUnknown {
1222 description: None,
1223 }),
1224 );
1225 map.insert(
1226 ::jacquard_common::smol_str::SmolStr::new_static(
1227 "description",
1228 ),
1229 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1230 description: None,
1231 format: None,
1232 default: None,
1233 min_length: None,
1234 max_length: Some(2560usize),
1235 min_graphemes: None,
1236 max_graphemes: Some(256usize),
1237 r#enum: None,
1238 r#const: None,
1239 known_values: None,
1240 }),
1241 );
1242 map.insert(
1243 ::jacquard_common::smol_str::SmolStr::new_static("did"),
1244 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1245 description: None,
1246 format: Some(
1247 ::jacquard_lexicon::lexicon::LexStringFormat::Did,
1248 ),
1249 default: None,
1250 min_length: None,
1251 max_length: None,
1252 min_graphemes: None,
1253 max_graphemes: None,
1254 r#enum: None,
1255 r#const: None,
1256 known_values: None,
1257 }),
1258 );
1259 map.insert(
1260 ::jacquard_common::smol_str::SmolStr::new_static(
1261 "displayName",
1262 ),
1263 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1264 description: None,
1265 format: None,
1266 default: None,
1267 min_length: None,
1268 max_length: Some(640usize),
1269 min_graphemes: None,
1270 max_graphemes: Some(64usize),
1271 r#enum: None,
1272 r#const: None,
1273 known_values: None,
1274 }),
1275 );
1276 map.insert(
1277 ::jacquard_common::smol_str::SmolStr::new_static("handle"),
1278 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1279 description: None,
1280 format: Some(
1281 ::jacquard_lexicon::lexicon::LexStringFormat::Handle,
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.insert(
1294 ::jacquard_common::smol_str::SmolStr::new_static(
1295 "indexedAt",
1296 ),
1297 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1298 description: None,
1299 format: Some(
1300 ::jacquard_lexicon::lexicon::LexStringFormat::Datetime,
1301 ),
1302 default: None,
1303 min_length: None,
1304 max_length: None,
1305 min_graphemes: None,
1306 max_graphemes: None,
1307 r#enum: None,
1308 r#const: None,
1309 known_values: None,
1310 }),
1311 );
1312 map.insert(
1313 ::jacquard_common::smol_str::SmolStr::new_static("labels"),
1314 ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
1315 description: None,
1316 items: ::jacquard_lexicon::lexicon::LexArrayItem::Ref(::jacquard_lexicon::lexicon::LexRef {
1317 description: None,
1318 r#ref: ::jacquard_common::CowStr::new_static(
1319 "com.atproto.label.defs#label",
1320 ),
1321 }),
1322 min_length: None,
1323 max_length: None,
1324 }),
1325 );
1326 map.insert(
1327 ::jacquard_common::smol_str::SmolStr::new_static("pronouns"),
1328 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1329 description: None,
1330 format: None,
1331 default: None,
1332 min_length: None,
1333 max_length: None,
1334 min_graphemes: None,
1335 max_graphemes: None,
1336 r#enum: None,
1337 r#const: None,
1338 known_values: None,
1339 }),
1340 );
1341 map.insert(
1342 ::jacquard_common::smol_str::SmolStr::new_static("status"),
1343 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
1344 description: None,
1345 r#ref: ::jacquard_common::CowStr::new_static("#statusView"),
1346 }),
1347 );
1348 map.insert(
1349 ::jacquard_common::smol_str::SmolStr::new_static(
1350 "verification",
1351 ),
1352 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
1353 description: None,
1354 r#ref: ::jacquard_common::CowStr::new_static(
1355 "#verificationState",
1356 ),
1357 }),
1358 );
1359 map.insert(
1360 ::jacquard_common::smol_str::SmolStr::new_static("viewer"),
1361 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
1362 description: None,
1363 r#ref: ::jacquard_common::CowStr::new_static("#viewerState"),
1364 }),
1365 );
1366 map
1367 },
1368 }),
1369 );
1370 map.insert(
1371 ::jacquard_common::smol_str::SmolStr::new_static("profileViewBasic"),
1372 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
1373 description: None,
1374 required: Some(
1375 vec![
1376 ::jacquard_common::smol_str::SmolStr::new_static("did"),
1377 ::jacquard_common::smol_str::SmolStr::new_static("handle")
1378 ],
1379 ),
1380 nullable: None,
1381 properties: {
1382 #[allow(unused_mut)]
1383 let mut map = ::std::collections::BTreeMap::new();
1384 map.insert(
1385 ::jacquard_common::smol_str::SmolStr::new_static(
1386 "associated",
1387 ),
1388 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
1389 description: None,
1390 r#ref: ::jacquard_common::CowStr::new_static(
1391 "#profileAssociated",
1392 ),
1393 }),
1394 );
1395 map.insert(
1396 ::jacquard_common::smol_str::SmolStr::new_static("avatar"),
1397 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1398 description: None,
1399 format: Some(
1400 ::jacquard_lexicon::lexicon::LexStringFormat::Uri,
1401 ),
1402 default: None,
1403 min_length: None,
1404 max_length: None,
1405 min_graphemes: None,
1406 max_graphemes: None,
1407 r#enum: None,
1408 r#const: None,
1409 known_values: None,
1410 }),
1411 );
1412 map.insert(
1413 ::jacquard_common::smol_str::SmolStr::new_static(
1414 "createdAt",
1415 ),
1416 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1417 description: None,
1418 format: Some(
1419 ::jacquard_lexicon::lexicon::LexStringFormat::Datetime,
1420 ),
1421 default: None,
1422 min_length: None,
1423 max_length: None,
1424 min_graphemes: None,
1425 max_graphemes: None,
1426 r#enum: None,
1427 r#const: None,
1428 known_values: None,
1429 }),
1430 );
1431 map.insert(
1432 ::jacquard_common::smol_str::SmolStr::new_static("debug"),
1433 ::jacquard_lexicon::lexicon::LexObjectProperty::Unknown(::jacquard_lexicon::lexicon::LexUnknown {
1434 description: None,
1435 }),
1436 );
1437 map.insert(
1438 ::jacquard_common::smol_str::SmolStr::new_static("did"),
1439 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1440 description: None,
1441 format: Some(
1442 ::jacquard_lexicon::lexicon::LexStringFormat::Did,
1443 ),
1444 default: None,
1445 min_length: None,
1446 max_length: None,
1447 min_graphemes: None,
1448 max_graphemes: None,
1449 r#enum: None,
1450 r#const: None,
1451 known_values: None,
1452 }),
1453 );
1454 map.insert(
1455 ::jacquard_common::smol_str::SmolStr::new_static(
1456 "displayName",
1457 ),
1458 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1459 description: None,
1460 format: None,
1461 default: None,
1462 min_length: None,
1463 max_length: Some(640usize),
1464 min_graphemes: None,
1465 max_graphemes: Some(64usize),
1466 r#enum: None,
1467 r#const: None,
1468 known_values: None,
1469 }),
1470 );
1471 map.insert(
1472 ::jacquard_common::smol_str::SmolStr::new_static("handle"),
1473 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1474 description: None,
1475 format: Some(
1476 ::jacquard_lexicon::lexicon::LexStringFormat::Handle,
1477 ),
1478 default: None,
1479 min_length: None,
1480 max_length: None,
1481 min_graphemes: None,
1482 max_graphemes: None,
1483 r#enum: None,
1484 r#const: None,
1485 known_values: None,
1486 }),
1487 );
1488 map.insert(
1489 ::jacquard_common::smol_str::SmolStr::new_static("labels"),
1490 ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
1491 description: None,
1492 items: ::jacquard_lexicon::lexicon::LexArrayItem::Ref(::jacquard_lexicon::lexicon::LexRef {
1493 description: None,
1494 r#ref: ::jacquard_common::CowStr::new_static(
1495 "com.atproto.label.defs#label",
1496 ),
1497 }),
1498 min_length: None,
1499 max_length: None,
1500 }),
1501 );
1502 map.insert(
1503 ::jacquard_common::smol_str::SmolStr::new_static("pronouns"),
1504 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1505 description: None,
1506 format: None,
1507 default: None,
1508 min_length: None,
1509 max_length: None,
1510 min_graphemes: None,
1511 max_graphemes: None,
1512 r#enum: None,
1513 r#const: None,
1514 known_values: None,
1515 }),
1516 );
1517 map.insert(
1518 ::jacquard_common::smol_str::SmolStr::new_static("status"),
1519 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
1520 description: None,
1521 r#ref: ::jacquard_common::CowStr::new_static("#statusView"),
1522 }),
1523 );
1524 map.insert(
1525 ::jacquard_common::smol_str::SmolStr::new_static(
1526 "verification",
1527 ),
1528 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
1529 description: None,
1530 r#ref: ::jacquard_common::CowStr::new_static(
1531 "#verificationState",
1532 ),
1533 }),
1534 );
1535 map.insert(
1536 ::jacquard_common::smol_str::SmolStr::new_static("viewer"),
1537 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
1538 description: None,
1539 r#ref: ::jacquard_common::CowStr::new_static("#viewerState"),
1540 }),
1541 );
1542 map
1543 },
1544 }),
1545 );
1546 map.insert(
1547 ::jacquard_common::smol_str::SmolStr::new_static("profileViewDetailed"),
1548 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
1549 description: None,
1550 required: Some(
1551 vec![
1552 ::jacquard_common::smol_str::SmolStr::new_static("did"),
1553 ::jacquard_common::smol_str::SmolStr::new_static("handle")
1554 ],
1555 ),
1556 nullable: None,
1557 properties: {
1558 #[allow(unused_mut)]
1559 let mut map = ::std::collections::BTreeMap::new();
1560 map.insert(
1561 ::jacquard_common::smol_str::SmolStr::new_static(
1562 "associated",
1563 ),
1564 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
1565 description: None,
1566 r#ref: ::jacquard_common::CowStr::new_static(
1567 "#profileAssociated",
1568 ),
1569 }),
1570 );
1571 map.insert(
1572 ::jacquard_common::smol_str::SmolStr::new_static("avatar"),
1573 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1574 description: None,
1575 format: Some(
1576 ::jacquard_lexicon::lexicon::LexStringFormat::Uri,
1577 ),
1578 default: None,
1579 min_length: None,
1580 max_length: None,
1581 min_graphemes: None,
1582 max_graphemes: None,
1583 r#enum: None,
1584 r#const: None,
1585 known_values: None,
1586 }),
1587 );
1588 map.insert(
1589 ::jacquard_common::smol_str::SmolStr::new_static("banner"),
1590 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1591 description: None,
1592 format: Some(
1593 ::jacquard_lexicon::lexicon::LexStringFormat::Uri,
1594 ),
1595 default: None,
1596 min_length: None,
1597 max_length: None,
1598 min_graphemes: None,
1599 max_graphemes: None,
1600 r#enum: None,
1601 r#const: None,
1602 known_values: None,
1603 }),
1604 );
1605 map.insert(
1606 ::jacquard_common::smol_str::SmolStr::new_static(
1607 "createdAt",
1608 ),
1609 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1610 description: None,
1611 format: Some(
1612 ::jacquard_lexicon::lexicon::LexStringFormat::Datetime,
1613 ),
1614 default: None,
1615 min_length: None,
1616 max_length: None,
1617 min_graphemes: None,
1618 max_graphemes: None,
1619 r#enum: None,
1620 r#const: None,
1621 known_values: None,
1622 }),
1623 );
1624 map.insert(
1625 ::jacquard_common::smol_str::SmolStr::new_static("debug"),
1626 ::jacquard_lexicon::lexicon::LexObjectProperty::Unknown(::jacquard_lexicon::lexicon::LexUnknown {
1627 description: None,
1628 }),
1629 );
1630 map.insert(
1631 ::jacquard_common::smol_str::SmolStr::new_static(
1632 "description",
1633 ),
1634 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1635 description: None,
1636 format: None,
1637 default: None,
1638 min_length: None,
1639 max_length: Some(2560usize),
1640 min_graphemes: None,
1641 max_graphemes: Some(256usize),
1642 r#enum: None,
1643 r#const: None,
1644 known_values: None,
1645 }),
1646 );
1647 map.insert(
1648 ::jacquard_common::smol_str::SmolStr::new_static("did"),
1649 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1650 description: None,
1651 format: Some(
1652 ::jacquard_lexicon::lexicon::LexStringFormat::Did,
1653 ),
1654 default: None,
1655 min_length: None,
1656 max_length: None,
1657 min_graphemes: None,
1658 max_graphemes: None,
1659 r#enum: None,
1660 r#const: None,
1661 known_values: None,
1662 }),
1663 );
1664 map.insert(
1665 ::jacquard_common::smol_str::SmolStr::new_static(
1666 "displayName",
1667 ),
1668 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1669 description: None,
1670 format: None,
1671 default: None,
1672 min_length: None,
1673 max_length: Some(640usize),
1674 min_graphemes: None,
1675 max_graphemes: Some(64usize),
1676 r#enum: None,
1677 r#const: None,
1678 known_values: None,
1679 }),
1680 );
1681 map.insert(
1682 ::jacquard_common::smol_str::SmolStr::new_static(
1683 "followersCount",
1684 ),
1685 ::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger {
1686 description: None,
1687 default: None,
1688 minimum: None,
1689 maximum: None,
1690 r#enum: None,
1691 r#const: None,
1692 }),
1693 );
1694 map.insert(
1695 ::jacquard_common::smol_str::SmolStr::new_static(
1696 "followsCount",
1697 ),
1698 ::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger {
1699 description: None,
1700 default: None,
1701 minimum: None,
1702 maximum: None,
1703 r#enum: None,
1704 r#const: None,
1705 }),
1706 );
1707 map.insert(
1708 ::jacquard_common::smol_str::SmolStr::new_static("handle"),
1709 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1710 description: None,
1711 format: Some(
1712 ::jacquard_lexicon::lexicon::LexStringFormat::Handle,
1713 ),
1714 default: None,
1715 min_length: None,
1716 max_length: None,
1717 min_graphemes: None,
1718 max_graphemes: None,
1719 r#enum: None,
1720 r#const: None,
1721 known_values: None,
1722 }),
1723 );
1724 map.insert(
1725 ::jacquard_common::smol_str::SmolStr::new_static(
1726 "indexedAt",
1727 ),
1728 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1729 description: None,
1730 format: Some(
1731 ::jacquard_lexicon::lexicon::LexStringFormat::Datetime,
1732 ),
1733 default: None,
1734 min_length: None,
1735 max_length: None,
1736 min_graphemes: None,
1737 max_graphemes: None,
1738 r#enum: None,
1739 r#const: None,
1740 known_values: None,
1741 }),
1742 );
1743 map.insert(
1744 ::jacquard_common::smol_str::SmolStr::new_static(
1745 "joinedViaStarterPack",
1746 ),
1747 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
1748 description: None,
1749 r#ref: ::jacquard_common::CowStr::new_static(
1750 "app.bsky.graph.defs#starterPackViewBasic",
1751 ),
1752 }),
1753 );
1754 map.insert(
1755 ::jacquard_common::smol_str::SmolStr::new_static("labels"),
1756 ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
1757 description: None,
1758 items: ::jacquard_lexicon::lexicon::LexArrayItem::Ref(::jacquard_lexicon::lexicon::LexRef {
1759 description: None,
1760 r#ref: ::jacquard_common::CowStr::new_static(
1761 "com.atproto.label.defs#label",
1762 ),
1763 }),
1764 min_length: None,
1765 max_length: None,
1766 }),
1767 );
1768 map.insert(
1769 ::jacquard_common::smol_str::SmolStr::new_static(
1770 "pinnedPost",
1771 ),
1772 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
1773 description: None,
1774 r#ref: ::jacquard_common::CowStr::new_static(
1775 "com.atproto.repo.strongRef",
1776 ),
1777 }),
1778 );
1779 map.insert(
1780 ::jacquard_common::smol_str::SmolStr::new_static(
1781 "postsCount",
1782 ),
1783 ::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger {
1784 description: None,
1785 default: None,
1786 minimum: None,
1787 maximum: None,
1788 r#enum: None,
1789 r#const: None,
1790 }),
1791 );
1792 map.insert(
1793 ::jacquard_common::smol_str::SmolStr::new_static("pronouns"),
1794 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1795 description: None,
1796 format: None,
1797 default: None,
1798 min_length: None,
1799 max_length: None,
1800 min_graphemes: None,
1801 max_graphemes: None,
1802 r#enum: None,
1803 r#const: None,
1804 known_values: None,
1805 }),
1806 );
1807 map.insert(
1808 ::jacquard_common::smol_str::SmolStr::new_static("status"),
1809 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
1810 description: None,
1811 r#ref: ::jacquard_common::CowStr::new_static("#statusView"),
1812 }),
1813 );
1814 map.insert(
1815 ::jacquard_common::smol_str::SmolStr::new_static(
1816 "verification",
1817 ),
1818 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
1819 description: None,
1820 r#ref: ::jacquard_common::CowStr::new_static(
1821 "#verificationState",
1822 ),
1823 }),
1824 );
1825 map.insert(
1826 ::jacquard_common::smol_str::SmolStr::new_static("viewer"),
1827 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
1828 description: None,
1829 r#ref: ::jacquard_common::CowStr::new_static("#viewerState"),
1830 }),
1831 );
1832 map.insert(
1833 ::jacquard_common::smol_str::SmolStr::new_static("website"),
1834 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1835 description: None,
1836 format: Some(
1837 ::jacquard_lexicon::lexicon::LexStringFormat::Uri,
1838 ),
1839 default: None,
1840 min_length: None,
1841 max_length: None,
1842 min_graphemes: None,
1843 max_graphemes: None,
1844 r#enum: None,
1845 r#const: None,
1846 known_values: None,
1847 }),
1848 );
1849 map
1850 },
1851 }),
1852 );
1853 map.insert(
1854 ::jacquard_common::smol_str::SmolStr::new_static("savedFeed"),
1855 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
1856 description: None,
1857 required: Some(
1858 vec![
1859 ::jacquard_common::smol_str::SmolStr::new_static("id"),
1860 ::jacquard_common::smol_str::SmolStr::new_static("type"),
1861 ::jacquard_common::smol_str::SmolStr::new_static("value"),
1862 ::jacquard_common::smol_str::SmolStr::new_static("pinned")
1863 ],
1864 ),
1865 nullable: None,
1866 properties: {
1867 #[allow(unused_mut)]
1868 let mut map = ::std::collections::BTreeMap::new();
1869 map.insert(
1870 ::jacquard_common::smol_str::SmolStr::new_static("id"),
1871 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1872 description: None,
1873 format: None,
1874 default: None,
1875 min_length: None,
1876 max_length: None,
1877 min_graphemes: None,
1878 max_graphemes: None,
1879 r#enum: None,
1880 r#const: None,
1881 known_values: None,
1882 }),
1883 );
1884 map.insert(
1885 ::jacquard_common::smol_str::SmolStr::new_static("pinned"),
1886 ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
1887 description: None,
1888 default: None,
1889 r#const: None,
1890 }),
1891 );
1892 map.insert(
1893 ::jacquard_common::smol_str::SmolStr::new_static("type"),
1894 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1895 description: None,
1896 format: None,
1897 default: None,
1898 min_length: None,
1899 max_length: None,
1900 min_graphemes: None,
1901 max_graphemes: None,
1902 r#enum: None,
1903 r#const: None,
1904 known_values: None,
1905 }),
1906 );
1907 map.insert(
1908 ::jacquard_common::smol_str::SmolStr::new_static("value"),
1909 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
1910 description: None,
1911 format: None,
1912 default: None,
1913 min_length: None,
1914 max_length: None,
1915 min_graphemes: None,
1916 max_graphemes: None,
1917 r#enum: None,
1918 r#const: None,
1919 known_values: None,
1920 }),
1921 );
1922 map
1923 },
1924 }),
1925 );
1926 map.insert(
1927 ::jacquard_common::smol_str::SmolStr::new_static("savedFeedsPref"),
1928 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
1929 description: None,
1930 required: Some(
1931 vec![
1932 ::jacquard_common::smol_str::SmolStr::new_static("pinned"),
1933 ::jacquard_common::smol_str::SmolStr::new_static("saved")
1934 ],
1935 ),
1936 nullable: None,
1937 properties: {
1938 #[allow(unused_mut)]
1939 let mut map = ::std::collections::BTreeMap::new();
1940 map.insert(
1941 ::jacquard_common::smol_str::SmolStr::new_static("pinned"),
1942 ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
1943 description: None,
1944 items: ::jacquard_lexicon::lexicon::LexArrayItem::String(::jacquard_lexicon::lexicon::LexString {
1945 description: None,
1946 format: Some(
1947 ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
1948 ),
1949 default: None,
1950 min_length: None,
1951 max_length: None,
1952 min_graphemes: None,
1953 max_graphemes: None,
1954 r#enum: None,
1955 r#const: None,
1956 known_values: None,
1957 }),
1958 min_length: None,
1959 max_length: None,
1960 }),
1961 );
1962 map.insert(
1963 ::jacquard_common::smol_str::SmolStr::new_static("saved"),
1964 ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
1965 description: None,
1966 items: ::jacquard_lexicon::lexicon::LexArrayItem::String(::jacquard_lexicon::lexicon::LexString {
1967 description: None,
1968 format: Some(
1969 ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
1970 ),
1971 default: None,
1972 min_length: None,
1973 max_length: None,
1974 min_graphemes: None,
1975 max_graphemes: None,
1976 r#enum: None,
1977 r#const: None,
1978 known_values: None,
1979 }),
1980 min_length: None,
1981 max_length: None,
1982 }),
1983 );
1984 map.insert(
1985 ::jacquard_common::smol_str::SmolStr::new_static(
1986 "timelineIndex",
1987 ),
1988 ::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger {
1989 description: None,
1990 default: None,
1991 minimum: None,
1992 maximum: None,
1993 r#enum: None,
1994 r#const: None,
1995 }),
1996 );
1997 map
1998 },
1999 }),
2000 );
2001 map.insert(
2002 ::jacquard_common::smol_str::SmolStr::new_static("savedFeedsPrefV2"),
2003 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
2004 description: None,
2005 required: Some(
2006 vec![::jacquard_common::smol_str::SmolStr::new_static("items")],
2007 ),
2008 nullable: None,
2009 properties: {
2010 #[allow(unused_mut)]
2011 let mut map = ::std::collections::BTreeMap::new();
2012 map.insert(
2013 ::jacquard_common::smol_str::SmolStr::new_static("items"),
2014 ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
2015 description: None,
2016 items: ::jacquard_lexicon::lexicon::LexArrayItem::Ref(::jacquard_lexicon::lexicon::LexRef {
2017 description: None,
2018 r#ref: ::jacquard_common::CowStr::new_static(
2019 "app.bsky.actor.defs#savedFeed",
2020 ),
2021 }),
2022 min_length: None,
2023 max_length: None,
2024 }),
2025 );
2026 map
2027 },
2028 }),
2029 );
2030 map.insert(
2031 ::jacquard_common::smol_str::SmolStr::new_static("statusView"),
2032 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
2033 description: None,
2034 required: Some(
2035 vec![
2036 ::jacquard_common::smol_str::SmolStr::new_static("status"),
2037 ::jacquard_common::smol_str::SmolStr::new_static("record")
2038 ],
2039 ),
2040 nullable: None,
2041 properties: {
2042 #[allow(unused_mut)]
2043 let mut map = ::std::collections::BTreeMap::new();
2044 map.insert(
2045 ::jacquard_common::smol_str::SmolStr::new_static("embed"),
2046 ::jacquard_lexicon::lexicon::LexObjectProperty::Union(::jacquard_lexicon::lexicon::LexRefUnion {
2047 description: Some(
2048 ::jacquard_common::CowStr::new_static(
2049 "An optional embed associated with the status.",
2050 ),
2051 ),
2052 refs: vec![
2053 ::jacquard_common::CowStr::new_static("app.bsky.embed.external#view")
2054 ],
2055 closed: None,
2056 }),
2057 );
2058 map.insert(
2059 ::jacquard_common::smol_str::SmolStr::new_static(
2060 "expiresAt",
2061 ),
2062 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
2063 description: Some(
2064 ::jacquard_common::CowStr::new_static(
2065 "The date when this status will expire. The application might choose to no longer return the status after expiration.",
2066 ),
2067 ),
2068 format: Some(
2069 ::jacquard_lexicon::lexicon::LexStringFormat::Datetime,
2070 ),
2071 default: None,
2072 min_length: None,
2073 max_length: None,
2074 min_graphemes: None,
2075 max_graphemes: None,
2076 r#enum: None,
2077 r#const: None,
2078 known_values: None,
2079 }),
2080 );
2081 map.insert(
2082 ::jacquard_common::smol_str::SmolStr::new_static("isActive"),
2083 ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
2084 description: None,
2085 default: None,
2086 r#const: None,
2087 }),
2088 );
2089 map.insert(
2090 ::jacquard_common::smol_str::SmolStr::new_static("record"),
2091 ::jacquard_lexicon::lexicon::LexObjectProperty::Unknown(::jacquard_lexicon::lexicon::LexUnknown {
2092 description: None,
2093 }),
2094 );
2095 map.insert(
2096 ::jacquard_common::smol_str::SmolStr::new_static("status"),
2097 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
2098 description: Some(
2099 ::jacquard_common::CowStr::new_static(
2100 "The status for the account.",
2101 ),
2102 ),
2103 format: None,
2104 default: None,
2105 min_length: None,
2106 max_length: None,
2107 min_graphemes: None,
2108 max_graphemes: None,
2109 r#enum: None,
2110 r#const: None,
2111 known_values: None,
2112 }),
2113 );
2114 map
2115 },
2116 }),
2117 );
2118 map.insert(
2119 ::jacquard_common::smol_str::SmolStr::new_static("threadViewPref"),
2120 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
2121 description: None,
2122 required: None,
2123 nullable: None,
2124 properties: {
2125 #[allow(unused_mut)]
2126 let mut map = ::std::collections::BTreeMap::new();
2127 map.insert(
2128 ::jacquard_common::smol_str::SmolStr::new_static(
2129 "prioritizeFollowedUsers",
2130 ),
2131 ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
2132 description: None,
2133 default: None,
2134 r#const: None,
2135 }),
2136 );
2137 map.insert(
2138 ::jacquard_common::smol_str::SmolStr::new_static("sort"),
2139 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
2140 description: Some(
2141 ::jacquard_common::CowStr::new_static(
2142 "Sorting mode for threads.",
2143 ),
2144 ),
2145 format: None,
2146 default: None,
2147 min_length: None,
2148 max_length: None,
2149 min_graphemes: None,
2150 max_graphemes: None,
2151 r#enum: None,
2152 r#const: None,
2153 known_values: None,
2154 }),
2155 );
2156 map
2157 },
2158 }),
2159 );
2160 map.insert(
2161 ::jacquard_common::smol_str::SmolStr::new_static("verificationPrefs"),
2162 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
2163 description: Some(
2164 ::jacquard_common::CowStr::new_static(
2165 "Preferences for how verified accounts appear in the app.",
2166 ),
2167 ),
2168 required: Some(vec![]),
2169 nullable: None,
2170 properties: {
2171 #[allow(unused_mut)]
2172 let mut map = ::std::collections::BTreeMap::new();
2173 map.insert(
2174 ::jacquard_common::smol_str::SmolStr::new_static(
2175 "hideBadges",
2176 ),
2177 ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
2178 description: None,
2179 default: None,
2180 r#const: None,
2181 }),
2182 );
2183 map
2184 },
2185 }),
2186 );
2187 map.insert(
2188 ::jacquard_common::smol_str::SmolStr::new_static("verificationState"),
2189 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
2190 description: Some(
2191 ::jacquard_common::CowStr::new_static(
2192 "Represents the verification information about the user this object is attached to.",
2193 ),
2194 ),
2195 required: Some(
2196 vec![
2197 ::jacquard_common::smol_str::SmolStr::new_static("verifications"),
2198 ::jacquard_common::smol_str::SmolStr::new_static("verifiedStatus"),
2199 ::jacquard_common::smol_str::SmolStr::new_static("trustedVerifierStatus")
2200 ],
2201 ),
2202 nullable: None,
2203 properties: {
2204 #[allow(unused_mut)]
2205 let mut map = ::std::collections::BTreeMap::new();
2206 map.insert(
2207 ::jacquard_common::smol_str::SmolStr::new_static(
2208 "trustedVerifierStatus",
2209 ),
2210 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
2211 description: Some(
2212 ::jacquard_common::CowStr::new_static(
2213 "The user's status as a trusted verifier.",
2214 ),
2215 ),
2216 format: None,
2217 default: None,
2218 min_length: None,
2219 max_length: None,
2220 min_graphemes: None,
2221 max_graphemes: None,
2222 r#enum: None,
2223 r#const: None,
2224 known_values: None,
2225 }),
2226 );
2227 map.insert(
2228 ::jacquard_common::smol_str::SmolStr::new_static(
2229 "verifications",
2230 ),
2231 ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
2232 description: Some(
2233 ::jacquard_common::CowStr::new_static(
2234 "All verifications issued by trusted verifiers on behalf of this user. Verifications by untrusted verifiers are not included.",
2235 ),
2236 ),
2237 items: ::jacquard_lexicon::lexicon::LexArrayItem::Ref(::jacquard_lexicon::lexicon::LexRef {
2238 description: None,
2239 r#ref: ::jacquard_common::CowStr::new_static(
2240 "#verificationView",
2241 ),
2242 }),
2243 min_length: None,
2244 max_length: None,
2245 }),
2246 );
2247 map.insert(
2248 ::jacquard_common::smol_str::SmolStr::new_static(
2249 "verifiedStatus",
2250 ),
2251 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
2252 description: Some(
2253 ::jacquard_common::CowStr::new_static(
2254 "The user's status as a verified account.",
2255 ),
2256 ),
2257 format: None,
2258 default: None,
2259 min_length: None,
2260 max_length: None,
2261 min_graphemes: None,
2262 max_graphemes: None,
2263 r#enum: None,
2264 r#const: None,
2265 known_values: None,
2266 }),
2267 );
2268 map
2269 },
2270 }),
2271 );
2272 map.insert(
2273 ::jacquard_common::smol_str::SmolStr::new_static("verificationView"),
2274 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
2275 description: Some(
2276 ::jacquard_common::CowStr::new_static(
2277 "An individual verification for an associated subject.",
2278 ),
2279 ),
2280 required: Some(
2281 vec![
2282 ::jacquard_common::smol_str::SmolStr::new_static("issuer"),
2283 ::jacquard_common::smol_str::SmolStr::new_static("uri"),
2284 ::jacquard_common::smol_str::SmolStr::new_static("isValid"),
2285 ::jacquard_common::smol_str::SmolStr::new_static("createdAt")
2286 ],
2287 ),
2288 nullable: None,
2289 properties: {
2290 #[allow(unused_mut)]
2291 let mut map = ::std::collections::BTreeMap::new();
2292 map.insert(
2293 ::jacquard_common::smol_str::SmolStr::new_static(
2294 "createdAt",
2295 ),
2296 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
2297 description: Some(
2298 ::jacquard_common::CowStr::new_static(
2299 "Timestamp when the verification was created.",
2300 ),
2301 ),
2302 format: Some(
2303 ::jacquard_lexicon::lexicon::LexStringFormat::Datetime,
2304 ),
2305 default: None,
2306 min_length: None,
2307 max_length: None,
2308 min_graphemes: None,
2309 max_graphemes: None,
2310 r#enum: None,
2311 r#const: None,
2312 known_values: None,
2313 }),
2314 );
2315 map.insert(
2316 ::jacquard_common::smol_str::SmolStr::new_static("isValid"),
2317 ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
2318 description: None,
2319 default: None,
2320 r#const: None,
2321 }),
2322 );
2323 map.insert(
2324 ::jacquard_common::smol_str::SmolStr::new_static("issuer"),
2325 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
2326 description: Some(
2327 ::jacquard_common::CowStr::new_static(
2328 "The user who issued this verification.",
2329 ),
2330 ),
2331 format: Some(
2332 ::jacquard_lexicon::lexicon::LexStringFormat::Did,
2333 ),
2334 default: None,
2335 min_length: None,
2336 max_length: None,
2337 min_graphemes: None,
2338 max_graphemes: None,
2339 r#enum: None,
2340 r#const: None,
2341 known_values: None,
2342 }),
2343 );
2344 map.insert(
2345 ::jacquard_common::smol_str::SmolStr::new_static("uri"),
2346 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
2347 description: Some(
2348 ::jacquard_common::CowStr::new_static(
2349 "The AT-URI of the verification record.",
2350 ),
2351 ),
2352 format: Some(
2353 ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
2354 ),
2355 default: None,
2356 min_length: None,
2357 max_length: None,
2358 min_graphemes: None,
2359 max_graphemes: None,
2360 r#enum: None,
2361 r#const: None,
2362 known_values: None,
2363 }),
2364 );
2365 map
2366 },
2367 }),
2368 );
2369 map.insert(
2370 ::jacquard_common::smol_str::SmolStr::new_static("viewerState"),
2371 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
2372 description: Some(
2373 ::jacquard_common::CowStr::new_static(
2374 "Metadata about the requesting account's relationship with the subject account. Only has meaningful content for authed requests.",
2375 ),
2376 ),
2377 required: None,
2378 nullable: None,
2379 properties: {
2380 #[allow(unused_mut)]
2381 let mut map = ::std::collections::BTreeMap::new();
2382 map.insert(
2383 ::jacquard_common::smol_str::SmolStr::new_static(
2384 "activitySubscription",
2385 ),
2386 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
2387 description: None,
2388 r#ref: ::jacquard_common::CowStr::new_static(
2389 "app.bsky.notification.defs#activitySubscription",
2390 ),
2391 }),
2392 );
2393 map.insert(
2394 ::jacquard_common::smol_str::SmolStr::new_static(
2395 "blockedBy",
2396 ),
2397 ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
2398 description: None,
2399 default: None,
2400 r#const: None,
2401 }),
2402 );
2403 map.insert(
2404 ::jacquard_common::smol_str::SmolStr::new_static("blocking"),
2405 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
2406 description: None,
2407 format: Some(
2408 ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
2409 ),
2410 default: None,
2411 min_length: None,
2412 max_length: None,
2413 min_graphemes: None,
2414 max_graphemes: None,
2415 r#enum: None,
2416 r#const: None,
2417 known_values: None,
2418 }),
2419 );
2420 map.insert(
2421 ::jacquard_common::smol_str::SmolStr::new_static(
2422 "blockingByList",
2423 ),
2424 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
2425 description: None,
2426 r#ref: ::jacquard_common::CowStr::new_static(
2427 "app.bsky.graph.defs#listViewBasic",
2428 ),
2429 }),
2430 );
2431 map.insert(
2432 ::jacquard_common::smol_str::SmolStr::new_static(
2433 "followedBy",
2434 ),
2435 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
2436 description: None,
2437 format: Some(
2438 ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
2439 ),
2440 default: None,
2441 min_length: None,
2442 max_length: None,
2443 min_graphemes: None,
2444 max_graphemes: None,
2445 r#enum: None,
2446 r#const: None,
2447 known_values: None,
2448 }),
2449 );
2450 map.insert(
2451 ::jacquard_common::smol_str::SmolStr::new_static(
2452 "following",
2453 ),
2454 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
2455 description: None,
2456 format: Some(
2457 ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
2458 ),
2459 default: None,
2460 min_length: None,
2461 max_length: None,
2462 min_graphemes: None,
2463 max_graphemes: None,
2464 r#enum: None,
2465 r#const: None,
2466 known_values: None,
2467 }),
2468 );
2469 map.insert(
2470 ::jacquard_common::smol_str::SmolStr::new_static(
2471 "knownFollowers",
2472 ),
2473 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
2474 description: None,
2475 r#ref: ::jacquard_common::CowStr::new_static(
2476 "#knownFollowers",
2477 ),
2478 }),
2479 );
2480 map.insert(
2481 ::jacquard_common::smol_str::SmolStr::new_static("muted"),
2482 ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
2483 description: None,
2484 default: None,
2485 r#const: None,
2486 }),
2487 );
2488 map.insert(
2489 ::jacquard_common::smol_str::SmolStr::new_static(
2490 "mutedByList",
2491 ),
2492 ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
2493 description: None,
2494 r#ref: ::jacquard_common::CowStr::new_static(
2495 "app.bsky.graph.defs#listViewBasic",
2496 ),
2497 }),
2498 );
2499 map
2500 },
2501 }),
2502 );
2503 map
2504 },
2505 }
2506}
2507
2508impl<'a> ::jacquard_lexicon::schema::LexiconSchema for AdultContentPref<'a> {
2509 fn nsid() -> &'static str {
2510 "app.bsky.actor.defs"
2511 }
2512 fn def_name() -> &'static str {
2513 "adultContentPref"
2514 }
2515 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
2516 lexicon_doc_app_bsky_actor_defs()
2517 }
2518 fn validate(
2519 &self,
2520 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
2521 Ok(())
2522 }
2523}
2524
2525#[jacquard_derive::lexicon]
2527#[derive(
2528 serde::Serialize,
2529 serde::Deserialize,
2530 Debug,
2531 Clone,
2532 PartialEq,
2533 Eq,
2534 jacquard_derive::IntoStatic,
2535 Default
2536)]
2537#[serde(rename_all = "camelCase")]
2538pub struct BskyAppProgressGuide<'a> {
2539 #[serde(borrow)]
2540 pub guide: jacquard_common::CowStr<'a>,
2541}
2542
2543impl<'a> ::jacquard_lexicon::schema::LexiconSchema for BskyAppProgressGuide<'a> {
2544 fn nsid() -> &'static str {
2545 "app.bsky.actor.defs"
2546 }
2547 fn def_name() -> &'static str {
2548 "bskyAppProgressGuide"
2549 }
2550 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
2551 lexicon_doc_app_bsky_actor_defs()
2552 }
2553 fn validate(
2554 &self,
2555 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
2556 {
2557 let value = &self.guide;
2558 #[allow(unused_comparisons)]
2559 if <str>::len(value.as_ref()) > 100usize {
2560 return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
2561 path: ::jacquard_lexicon::validation::ValidationPath::from_field(
2562 "guide",
2563 ),
2564 max: 100usize,
2565 actual: <str>::len(value.as_ref()),
2566 });
2567 }
2568 }
2569 Ok(())
2570 }
2571}
2572
2573#[jacquard_derive::lexicon]
2575#[derive(
2576 serde::Serialize,
2577 serde::Deserialize,
2578 Debug,
2579 Clone,
2580 PartialEq,
2581 Eq,
2582 jacquard_derive::IntoStatic,
2583 Default
2584)]
2585#[serde(rename_all = "camelCase")]
2586pub struct BskyAppStatePref<'a> {
2587 #[serde(skip_serializing_if = "std::option::Option::is_none")]
2588 #[serde(borrow)]
2589 pub active_progress_guide: std::option::Option<
2590 crate::app_bsky::actor::BskyAppProgressGuide<'a>,
2591 >,
2592 #[serde(skip_serializing_if = "std::option::Option::is_none")]
2594 #[serde(borrow)]
2595 pub nuxs: std::option::Option<Vec<crate::app_bsky::actor::Nux<'a>>>,
2596 #[serde(skip_serializing_if = "std::option::Option::is_none")]
2598 #[serde(borrow)]
2599 pub queued_nudges: std::option::Option<Vec<jacquard_common::CowStr<'a>>>,
2600}
2601
2602impl<'a> ::jacquard_lexicon::schema::LexiconSchema for BskyAppStatePref<'a> {
2603 fn nsid() -> &'static str {
2604 "app.bsky.actor.defs"
2605 }
2606 fn def_name() -> &'static str {
2607 "bskyAppStatePref"
2608 }
2609 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
2610 lexicon_doc_app_bsky_actor_defs()
2611 }
2612 fn validate(
2613 &self,
2614 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
2615 if let Some(ref value) = self.nuxs {
2616 #[allow(unused_comparisons)]
2617 if value.len() > 100usize {
2618 return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
2619 path: ::jacquard_lexicon::validation::ValidationPath::from_field(
2620 "nuxs",
2621 ),
2622 max: 100usize,
2623 actual: value.len(),
2624 });
2625 }
2626 }
2627 if let Some(ref value) = self.queued_nudges {
2628 #[allow(unused_comparisons)]
2629 if value.len() > 1000usize {
2630 return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
2631 path: ::jacquard_lexicon::validation::ValidationPath::from_field(
2632 "queued_nudges",
2633 ),
2634 max: 1000usize,
2635 actual: value.len(),
2636 });
2637 }
2638 }
2639 Ok(())
2640 }
2641}
2642
2643#[jacquard_derive::lexicon]
2644#[derive(
2645 serde::Serialize,
2646 serde::Deserialize,
2647 Debug,
2648 Clone,
2649 PartialEq,
2650 Eq,
2651 jacquard_derive::IntoStatic,
2652 Default
2653)]
2654#[serde(rename_all = "camelCase")]
2655pub struct ContentLabelPref<'a> {
2656 #[serde(borrow)]
2657 pub label: jacquard_common::CowStr<'a>,
2658 #[serde(skip_serializing_if = "std::option::Option::is_none")]
2660 #[serde(borrow)]
2661 pub labeler_did: std::option::Option<jacquard_common::types::string::Did<'a>>,
2662 #[serde(borrow)]
2663 pub visibility: jacquard_common::CowStr<'a>,
2664}
2665
2666impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ContentLabelPref<'a> {
2667 fn nsid() -> &'static str {
2668 "app.bsky.actor.defs"
2669 }
2670 fn def_name() -> &'static str {
2671 "contentLabelPref"
2672 }
2673 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
2674 lexicon_doc_app_bsky_actor_defs()
2675 }
2676 fn validate(
2677 &self,
2678 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
2679 Ok(())
2680 }
2681}
2682
2683#[jacquard_derive::lexicon]
2684#[derive(
2685 serde::Serialize,
2686 serde::Deserialize,
2687 Debug,
2688 Clone,
2689 PartialEq,
2690 Eq,
2691 jacquard_derive::IntoStatic,
2692 Default
2693)]
2694#[serde(rename_all = "camelCase")]
2695pub struct FeedViewPref<'a> {
2696 #[serde(borrow)]
2698 pub feed: jacquard_common::CowStr<'a>,
2699 #[serde(skip_serializing_if = "std::option::Option::is_none")]
2701 pub hide_quote_posts: std::option::Option<bool>,
2702 #[serde(skip_serializing_if = "std::option::Option::is_none")]
2704 pub hide_replies: std::option::Option<bool>,
2705 #[serde(skip_serializing_if = "std::option::Option::is_none")]
2707 pub hide_replies_by_like_count: std::option::Option<i64>,
2708 #[serde(skip_serializing_if = "std::option::Option::is_none")]
2710 pub hide_replies_by_unfollowed: std::option::Option<bool>,
2711 #[serde(skip_serializing_if = "std::option::Option::is_none")]
2713 pub hide_reposts: std::option::Option<bool>,
2714}
2715
2716impl<'a> ::jacquard_lexicon::schema::LexiconSchema for FeedViewPref<'a> {
2717 fn nsid() -> &'static str {
2718 "app.bsky.actor.defs"
2719 }
2720 fn def_name() -> &'static str {
2721 "feedViewPref"
2722 }
2723 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
2724 lexicon_doc_app_bsky_actor_defs()
2725 }
2726 fn validate(
2727 &self,
2728 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
2729 Ok(())
2730 }
2731}
2732
2733#[jacquard_derive::lexicon]
2734#[derive(
2735 serde::Serialize,
2736 serde::Deserialize,
2737 Debug,
2738 Clone,
2739 PartialEq,
2740 Eq,
2741 jacquard_derive::IntoStatic
2742)]
2743#[serde(rename_all = "camelCase")]
2744pub struct HiddenPostsPref<'a> {
2745 #[serde(borrow)]
2747 pub items: Vec<jacquard_common::types::string::AtUri<'a>>,
2748}
2749
2750pub mod hidden_posts_pref_state {
2751
2752 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
2753 #[allow(unused)]
2754 use ::core::marker::PhantomData;
2755 mod sealed {
2756 pub trait Sealed {}
2757 }
2758 pub trait State: sealed::Sealed {
2760 type Items;
2761 }
2762 pub struct Empty(());
2764 impl sealed::Sealed for Empty {}
2765 impl State for Empty {
2766 type Items = Unset;
2767 }
2768 pub struct SetItems<S: State = Empty>(PhantomData<fn() -> S>);
2770 impl<S: State> sealed::Sealed for SetItems<S> {}
2771 impl<S: State> State for SetItems<S> {
2772 type Items = Set<members::items>;
2773 }
2774 #[allow(non_camel_case_types)]
2776 pub mod members {
2777 pub struct items(());
2779 }
2780}
2781
2782pub struct HiddenPostsPrefBuilder<'a, S: hidden_posts_pref_state::State> {
2784 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
2785 __unsafe_private_named: (
2786 ::core::option::Option<Vec<jacquard_common::types::string::AtUri<'a>>>,
2787 ),
2788 _phantom: ::core::marker::PhantomData<&'a ()>,
2789}
2790
2791impl<'a> HiddenPostsPref<'a> {
2792 pub fn new() -> HiddenPostsPrefBuilder<'a, hidden_posts_pref_state::Empty> {
2794 HiddenPostsPrefBuilder::new()
2795 }
2796}
2797
2798impl<'a> HiddenPostsPrefBuilder<'a, hidden_posts_pref_state::Empty> {
2799 pub fn new() -> Self {
2801 HiddenPostsPrefBuilder {
2802 _phantom_state: ::core::marker::PhantomData,
2803 __unsafe_private_named: (None,),
2804 _phantom: ::core::marker::PhantomData,
2805 }
2806 }
2807}
2808
2809impl<'a, S> HiddenPostsPrefBuilder<'a, S>
2810where
2811 S: hidden_posts_pref_state::State,
2812 S::Items: hidden_posts_pref_state::IsUnset,
2813{
2814 pub fn items(
2816 mut self,
2817 value: impl Into<Vec<jacquard_common::types::string::AtUri<'a>>>,
2818 ) -> HiddenPostsPrefBuilder<'a, hidden_posts_pref_state::SetItems<S>> {
2819 self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
2820 HiddenPostsPrefBuilder {
2821 _phantom_state: ::core::marker::PhantomData,
2822 __unsafe_private_named: self.__unsafe_private_named,
2823 _phantom: ::core::marker::PhantomData,
2824 }
2825 }
2826}
2827
2828impl<'a, S> HiddenPostsPrefBuilder<'a, S>
2829where
2830 S: hidden_posts_pref_state::State,
2831 S::Items: hidden_posts_pref_state::IsSet,
2832{
2833 pub fn build(self) -> HiddenPostsPref<'a> {
2835 HiddenPostsPref {
2836 items: self.__unsafe_private_named.0.unwrap(),
2837 extra_data: Default::default(),
2838 }
2839 }
2840 pub fn build_with_data(
2842 self,
2843 extra_data: std::collections::BTreeMap<
2844 jacquard_common::smol_str::SmolStr,
2845 jacquard_common::types::value::Data<'a>,
2846 >,
2847 ) -> HiddenPostsPref<'a> {
2848 HiddenPostsPref {
2849 items: self.__unsafe_private_named.0.unwrap(),
2850 extra_data: Some(extra_data),
2851 }
2852 }
2853}
2854
2855impl<'a> ::jacquard_lexicon::schema::LexiconSchema for HiddenPostsPref<'a> {
2856 fn nsid() -> &'static str {
2857 "app.bsky.actor.defs"
2858 }
2859 fn def_name() -> &'static str {
2860 "hiddenPostsPref"
2861 }
2862 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
2863 lexicon_doc_app_bsky_actor_defs()
2864 }
2865 fn validate(
2866 &self,
2867 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
2868 Ok(())
2869 }
2870}
2871
2872#[jacquard_derive::lexicon]
2873#[derive(
2874 serde::Serialize,
2875 serde::Deserialize,
2876 Debug,
2877 Clone,
2878 PartialEq,
2879 Eq,
2880 jacquard_derive::IntoStatic
2881)]
2882#[serde(rename_all = "camelCase")]
2883pub struct InterestsPref<'a> {
2884 #[serde(borrow)]
2886 pub tags: Vec<jacquard_common::CowStr<'a>>,
2887}
2888
2889pub mod interests_pref_state {
2890
2891 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
2892 #[allow(unused)]
2893 use ::core::marker::PhantomData;
2894 mod sealed {
2895 pub trait Sealed {}
2896 }
2897 pub trait State: sealed::Sealed {
2899 type Tags;
2900 }
2901 pub struct Empty(());
2903 impl sealed::Sealed for Empty {}
2904 impl State for Empty {
2905 type Tags = Unset;
2906 }
2907 pub struct SetTags<S: State = Empty>(PhantomData<fn() -> S>);
2909 impl<S: State> sealed::Sealed for SetTags<S> {}
2910 impl<S: State> State for SetTags<S> {
2911 type Tags = Set<members::tags>;
2912 }
2913 #[allow(non_camel_case_types)]
2915 pub mod members {
2916 pub struct tags(());
2918 }
2919}
2920
2921pub struct InterestsPrefBuilder<'a, S: interests_pref_state::State> {
2923 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
2924 __unsafe_private_named: (::core::option::Option<Vec<jacquard_common::CowStr<'a>>>,),
2925 _phantom: ::core::marker::PhantomData<&'a ()>,
2926}
2927
2928impl<'a> InterestsPref<'a> {
2929 pub fn new() -> InterestsPrefBuilder<'a, interests_pref_state::Empty> {
2931 InterestsPrefBuilder::new()
2932 }
2933}
2934
2935impl<'a> InterestsPrefBuilder<'a, interests_pref_state::Empty> {
2936 pub fn new() -> Self {
2938 InterestsPrefBuilder {
2939 _phantom_state: ::core::marker::PhantomData,
2940 __unsafe_private_named: (None,),
2941 _phantom: ::core::marker::PhantomData,
2942 }
2943 }
2944}
2945
2946impl<'a, S> InterestsPrefBuilder<'a, S>
2947where
2948 S: interests_pref_state::State,
2949 S::Tags: interests_pref_state::IsUnset,
2950{
2951 pub fn tags(
2953 mut self,
2954 value: impl Into<Vec<jacquard_common::CowStr<'a>>>,
2955 ) -> InterestsPrefBuilder<'a, interests_pref_state::SetTags<S>> {
2956 self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
2957 InterestsPrefBuilder {
2958 _phantom_state: ::core::marker::PhantomData,
2959 __unsafe_private_named: self.__unsafe_private_named,
2960 _phantom: ::core::marker::PhantomData,
2961 }
2962 }
2963}
2964
2965impl<'a, S> InterestsPrefBuilder<'a, S>
2966where
2967 S: interests_pref_state::State,
2968 S::Tags: interests_pref_state::IsSet,
2969{
2970 pub fn build(self) -> InterestsPref<'a> {
2972 InterestsPref {
2973 tags: self.__unsafe_private_named.0.unwrap(),
2974 extra_data: Default::default(),
2975 }
2976 }
2977 pub fn build_with_data(
2979 self,
2980 extra_data: std::collections::BTreeMap<
2981 jacquard_common::smol_str::SmolStr,
2982 jacquard_common::types::value::Data<'a>,
2983 >,
2984 ) -> InterestsPref<'a> {
2985 InterestsPref {
2986 tags: self.__unsafe_private_named.0.unwrap(),
2987 extra_data: Some(extra_data),
2988 }
2989 }
2990}
2991
2992impl<'a> ::jacquard_lexicon::schema::LexiconSchema for InterestsPref<'a> {
2993 fn nsid() -> &'static str {
2994 "app.bsky.actor.defs"
2995 }
2996 fn def_name() -> &'static str {
2997 "interestsPref"
2998 }
2999 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
3000 lexicon_doc_app_bsky_actor_defs()
3001 }
3002 fn validate(
3003 &self,
3004 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
3005 {
3006 let value = &self.tags;
3007 #[allow(unused_comparisons)]
3008 if value.len() > 100usize {
3009 return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
3010 path: ::jacquard_lexicon::validation::ValidationPath::from_field(
3011 "tags",
3012 ),
3013 max: 100usize,
3014 actual: value.len(),
3015 });
3016 }
3017 }
3018 Ok(())
3019 }
3020}
3021
3022#[jacquard_derive::lexicon]
3024#[derive(
3025 serde::Serialize,
3026 serde::Deserialize,
3027 Debug,
3028 Clone,
3029 PartialEq,
3030 Eq,
3031 jacquard_derive::IntoStatic
3032)]
3033#[serde(rename_all = "camelCase")]
3034pub struct KnownFollowers<'a> {
3035 pub count: i64,
3036 #[serde(borrow)]
3037 pub followers: Vec<crate::app_bsky::actor::ProfileViewBasic<'a>>,
3038}
3039
3040pub mod known_followers_state {
3041
3042 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
3043 #[allow(unused)]
3044 use ::core::marker::PhantomData;
3045 mod sealed {
3046 pub trait Sealed {}
3047 }
3048 pub trait State: sealed::Sealed {
3050 type Count;
3051 type Followers;
3052 }
3053 pub struct Empty(());
3055 impl sealed::Sealed for Empty {}
3056 impl State for Empty {
3057 type Count = Unset;
3058 type Followers = Unset;
3059 }
3060 pub struct SetCount<S: State = Empty>(PhantomData<fn() -> S>);
3062 impl<S: State> sealed::Sealed for SetCount<S> {}
3063 impl<S: State> State for SetCount<S> {
3064 type Count = Set<members::count>;
3065 type Followers = S::Followers;
3066 }
3067 pub struct SetFollowers<S: State = Empty>(PhantomData<fn() -> S>);
3069 impl<S: State> sealed::Sealed for SetFollowers<S> {}
3070 impl<S: State> State for SetFollowers<S> {
3071 type Count = S::Count;
3072 type Followers = Set<members::followers>;
3073 }
3074 #[allow(non_camel_case_types)]
3076 pub mod members {
3077 pub struct count(());
3079 pub struct followers(());
3081 }
3082}
3083
3084pub struct KnownFollowersBuilder<'a, S: known_followers_state::State> {
3086 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
3087 __unsafe_private_named: (
3088 ::core::option::Option<i64>,
3089 ::core::option::Option<Vec<crate::app_bsky::actor::ProfileViewBasic<'a>>>,
3090 ),
3091 _phantom: ::core::marker::PhantomData<&'a ()>,
3092}
3093
3094impl<'a> KnownFollowers<'a> {
3095 pub fn new() -> KnownFollowersBuilder<'a, known_followers_state::Empty> {
3097 KnownFollowersBuilder::new()
3098 }
3099}
3100
3101impl<'a> KnownFollowersBuilder<'a, known_followers_state::Empty> {
3102 pub fn new() -> Self {
3104 KnownFollowersBuilder {
3105 _phantom_state: ::core::marker::PhantomData,
3106 __unsafe_private_named: (None, None),
3107 _phantom: ::core::marker::PhantomData,
3108 }
3109 }
3110}
3111
3112impl<'a, S> KnownFollowersBuilder<'a, S>
3113where
3114 S: known_followers_state::State,
3115 S::Count: known_followers_state::IsUnset,
3116{
3117 pub fn count(
3119 mut self,
3120 value: impl Into<i64>,
3121 ) -> KnownFollowersBuilder<'a, known_followers_state::SetCount<S>> {
3122 self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
3123 KnownFollowersBuilder {
3124 _phantom_state: ::core::marker::PhantomData,
3125 __unsafe_private_named: self.__unsafe_private_named,
3126 _phantom: ::core::marker::PhantomData,
3127 }
3128 }
3129}
3130
3131impl<'a, S> KnownFollowersBuilder<'a, S>
3132where
3133 S: known_followers_state::State,
3134 S::Followers: known_followers_state::IsUnset,
3135{
3136 pub fn followers(
3138 mut self,
3139 value: impl Into<Vec<crate::app_bsky::actor::ProfileViewBasic<'a>>>,
3140 ) -> KnownFollowersBuilder<'a, known_followers_state::SetFollowers<S>> {
3141 self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
3142 KnownFollowersBuilder {
3143 _phantom_state: ::core::marker::PhantomData,
3144 __unsafe_private_named: self.__unsafe_private_named,
3145 _phantom: ::core::marker::PhantomData,
3146 }
3147 }
3148}
3149
3150impl<'a, S> KnownFollowersBuilder<'a, S>
3151where
3152 S: known_followers_state::State,
3153 S::Count: known_followers_state::IsSet,
3154 S::Followers: known_followers_state::IsSet,
3155{
3156 pub fn build(self) -> KnownFollowers<'a> {
3158 KnownFollowers {
3159 count: self.__unsafe_private_named.0.unwrap(),
3160 followers: self.__unsafe_private_named.1.unwrap(),
3161 extra_data: Default::default(),
3162 }
3163 }
3164 pub fn build_with_data(
3166 self,
3167 extra_data: std::collections::BTreeMap<
3168 jacquard_common::smol_str::SmolStr,
3169 jacquard_common::types::value::Data<'a>,
3170 >,
3171 ) -> KnownFollowers<'a> {
3172 KnownFollowers {
3173 count: self.__unsafe_private_named.0.unwrap(),
3174 followers: self.__unsafe_private_named.1.unwrap(),
3175 extra_data: Some(extra_data),
3176 }
3177 }
3178}
3179
3180impl<'a> ::jacquard_lexicon::schema::LexiconSchema for KnownFollowers<'a> {
3181 fn nsid() -> &'static str {
3182 "app.bsky.actor.defs"
3183 }
3184 fn def_name() -> &'static str {
3185 "knownFollowers"
3186 }
3187 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
3188 lexicon_doc_app_bsky_actor_defs()
3189 }
3190 fn validate(
3191 &self,
3192 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
3193 {
3194 let value = &self.followers;
3195 #[allow(unused_comparisons)]
3196 if value.len() > 5usize {
3197 return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
3198 path: ::jacquard_lexicon::validation::ValidationPath::from_field(
3199 "followers",
3200 ),
3201 max: 5usize,
3202 actual: value.len(),
3203 });
3204 }
3205 }
3206 {
3207 let value = &self.followers;
3208 #[allow(unused_comparisons)]
3209 if value.len() < 0usize {
3210 return Err(::jacquard_lexicon::validation::ConstraintError::MinLength {
3211 path: ::jacquard_lexicon::validation::ValidationPath::from_field(
3212 "followers",
3213 ),
3214 min: 0usize,
3215 actual: value.len(),
3216 });
3217 }
3218 }
3219 Ok(())
3220 }
3221}
3222
3223#[jacquard_derive::lexicon]
3224#[derive(
3225 serde::Serialize,
3226 serde::Deserialize,
3227 Debug,
3228 Clone,
3229 PartialEq,
3230 Eq,
3231 jacquard_derive::IntoStatic
3232)]
3233#[serde(rename_all = "camelCase")]
3234pub struct LabelerPrefItem<'a> {
3235 #[serde(borrow)]
3236 pub did: jacquard_common::types::string::Did<'a>,
3237}
3238
3239pub mod labeler_pref_item_state {
3240
3241 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
3242 #[allow(unused)]
3243 use ::core::marker::PhantomData;
3244 mod sealed {
3245 pub trait Sealed {}
3246 }
3247 pub trait State: sealed::Sealed {
3249 type Did;
3250 }
3251 pub struct Empty(());
3253 impl sealed::Sealed for Empty {}
3254 impl State for Empty {
3255 type Did = Unset;
3256 }
3257 pub struct SetDid<S: State = Empty>(PhantomData<fn() -> S>);
3259 impl<S: State> sealed::Sealed for SetDid<S> {}
3260 impl<S: State> State for SetDid<S> {
3261 type Did = Set<members::did>;
3262 }
3263 #[allow(non_camel_case_types)]
3265 pub mod members {
3266 pub struct did(());
3268 }
3269}
3270
3271pub struct LabelerPrefItemBuilder<'a, S: labeler_pref_item_state::State> {
3273 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
3274 __unsafe_private_named: (
3275 ::core::option::Option<jacquard_common::types::string::Did<'a>>,
3276 ),
3277 _phantom: ::core::marker::PhantomData<&'a ()>,
3278}
3279
3280impl<'a> LabelerPrefItem<'a> {
3281 pub fn new() -> LabelerPrefItemBuilder<'a, labeler_pref_item_state::Empty> {
3283 LabelerPrefItemBuilder::new()
3284 }
3285}
3286
3287impl<'a> LabelerPrefItemBuilder<'a, labeler_pref_item_state::Empty> {
3288 pub fn new() -> Self {
3290 LabelerPrefItemBuilder {
3291 _phantom_state: ::core::marker::PhantomData,
3292 __unsafe_private_named: (None,),
3293 _phantom: ::core::marker::PhantomData,
3294 }
3295 }
3296}
3297
3298impl<'a, S> LabelerPrefItemBuilder<'a, S>
3299where
3300 S: labeler_pref_item_state::State,
3301 S::Did: labeler_pref_item_state::IsUnset,
3302{
3303 pub fn did(
3305 mut self,
3306 value: impl Into<jacquard_common::types::string::Did<'a>>,
3307 ) -> LabelerPrefItemBuilder<'a, labeler_pref_item_state::SetDid<S>> {
3308 self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
3309 LabelerPrefItemBuilder {
3310 _phantom_state: ::core::marker::PhantomData,
3311 __unsafe_private_named: self.__unsafe_private_named,
3312 _phantom: ::core::marker::PhantomData,
3313 }
3314 }
3315}
3316
3317impl<'a, S> LabelerPrefItemBuilder<'a, S>
3318where
3319 S: labeler_pref_item_state::State,
3320 S::Did: labeler_pref_item_state::IsSet,
3321{
3322 pub fn build(self) -> LabelerPrefItem<'a> {
3324 LabelerPrefItem {
3325 did: self.__unsafe_private_named.0.unwrap(),
3326 extra_data: Default::default(),
3327 }
3328 }
3329 pub fn build_with_data(
3331 self,
3332 extra_data: std::collections::BTreeMap<
3333 jacquard_common::smol_str::SmolStr,
3334 jacquard_common::types::value::Data<'a>,
3335 >,
3336 ) -> LabelerPrefItem<'a> {
3337 LabelerPrefItem {
3338 did: self.__unsafe_private_named.0.unwrap(),
3339 extra_data: Some(extra_data),
3340 }
3341 }
3342}
3343
3344impl<'a> ::jacquard_lexicon::schema::LexiconSchema for LabelerPrefItem<'a> {
3345 fn nsid() -> &'static str {
3346 "app.bsky.actor.defs"
3347 }
3348 fn def_name() -> &'static str {
3349 "labelerPrefItem"
3350 }
3351 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
3352 lexicon_doc_app_bsky_actor_defs()
3353 }
3354 fn validate(
3355 &self,
3356 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
3357 Ok(())
3358 }
3359}
3360
3361#[jacquard_derive::lexicon]
3362#[derive(
3363 serde::Serialize,
3364 serde::Deserialize,
3365 Debug,
3366 Clone,
3367 PartialEq,
3368 Eq,
3369 jacquard_derive::IntoStatic
3370)]
3371#[serde(rename_all = "camelCase")]
3372pub struct LabelersPref<'a> {
3373 #[serde(borrow)]
3374 pub labelers: Vec<crate::app_bsky::actor::LabelerPrefItem<'a>>,
3375}
3376
3377pub mod labelers_pref_state {
3378
3379 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
3380 #[allow(unused)]
3381 use ::core::marker::PhantomData;
3382 mod sealed {
3383 pub trait Sealed {}
3384 }
3385 pub trait State: sealed::Sealed {
3387 type Labelers;
3388 }
3389 pub struct Empty(());
3391 impl sealed::Sealed for Empty {}
3392 impl State for Empty {
3393 type Labelers = Unset;
3394 }
3395 pub struct SetLabelers<S: State = Empty>(PhantomData<fn() -> S>);
3397 impl<S: State> sealed::Sealed for SetLabelers<S> {}
3398 impl<S: State> State for SetLabelers<S> {
3399 type Labelers = Set<members::labelers>;
3400 }
3401 #[allow(non_camel_case_types)]
3403 pub mod members {
3404 pub struct labelers(());
3406 }
3407}
3408
3409pub struct LabelersPrefBuilder<'a, S: labelers_pref_state::State> {
3411 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
3412 __unsafe_private_named: (
3413 ::core::option::Option<Vec<crate::app_bsky::actor::LabelerPrefItem<'a>>>,
3414 ),
3415 _phantom: ::core::marker::PhantomData<&'a ()>,
3416}
3417
3418impl<'a> LabelersPref<'a> {
3419 pub fn new() -> LabelersPrefBuilder<'a, labelers_pref_state::Empty> {
3421 LabelersPrefBuilder::new()
3422 }
3423}
3424
3425impl<'a> LabelersPrefBuilder<'a, labelers_pref_state::Empty> {
3426 pub fn new() -> Self {
3428 LabelersPrefBuilder {
3429 _phantom_state: ::core::marker::PhantomData,
3430 __unsafe_private_named: (None,),
3431 _phantom: ::core::marker::PhantomData,
3432 }
3433 }
3434}
3435
3436impl<'a, S> LabelersPrefBuilder<'a, S>
3437where
3438 S: labelers_pref_state::State,
3439 S::Labelers: labelers_pref_state::IsUnset,
3440{
3441 pub fn labelers(
3443 mut self,
3444 value: impl Into<Vec<crate::app_bsky::actor::LabelerPrefItem<'a>>>,
3445 ) -> LabelersPrefBuilder<'a, labelers_pref_state::SetLabelers<S>> {
3446 self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
3447 LabelersPrefBuilder {
3448 _phantom_state: ::core::marker::PhantomData,
3449 __unsafe_private_named: self.__unsafe_private_named,
3450 _phantom: ::core::marker::PhantomData,
3451 }
3452 }
3453}
3454
3455impl<'a, S> LabelersPrefBuilder<'a, S>
3456where
3457 S: labelers_pref_state::State,
3458 S::Labelers: labelers_pref_state::IsSet,
3459{
3460 pub fn build(self) -> LabelersPref<'a> {
3462 LabelersPref {
3463 labelers: self.__unsafe_private_named.0.unwrap(),
3464 extra_data: Default::default(),
3465 }
3466 }
3467 pub fn build_with_data(
3469 self,
3470 extra_data: std::collections::BTreeMap<
3471 jacquard_common::smol_str::SmolStr,
3472 jacquard_common::types::value::Data<'a>,
3473 >,
3474 ) -> LabelersPref<'a> {
3475 LabelersPref {
3476 labelers: self.__unsafe_private_named.0.unwrap(),
3477 extra_data: Some(extra_data),
3478 }
3479 }
3480}
3481
3482impl<'a> ::jacquard_lexicon::schema::LexiconSchema for LabelersPref<'a> {
3483 fn nsid() -> &'static str {
3484 "app.bsky.actor.defs"
3485 }
3486 fn def_name() -> &'static str {
3487 "labelersPref"
3488 }
3489 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
3490 lexicon_doc_app_bsky_actor_defs()
3491 }
3492 fn validate(
3493 &self,
3494 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
3495 Ok(())
3496 }
3497}
3498
3499#[jacquard_derive::lexicon]
3501#[derive(
3502 serde::Serialize,
3503 serde::Deserialize,
3504 Debug,
3505 Clone,
3506 PartialEq,
3507 Eq,
3508 jacquard_derive::IntoStatic
3509)]
3510#[serde(rename_all = "camelCase")]
3511pub struct MutedWord<'a> {
3512 #[serde(skip_serializing_if = "std::option::Option::is_none")]
3514 #[serde(borrow)]
3515 pub actor_target: Option<jacquard_common::CowStr<'a>>,
3516 #[serde(skip_serializing_if = "std::option::Option::is_none")]
3518 pub expires_at: Option<jacquard_common::types::string::Datetime>,
3519 #[serde(skip_serializing_if = "std::option::Option::is_none")]
3520 #[serde(borrow)]
3521 pub id: Option<jacquard_common::CowStr<'a>>,
3522 #[serde(borrow)]
3524 pub targets: Vec<crate::app_bsky::actor::MutedWordTarget<'a>>,
3525 #[serde(borrow)]
3527 pub value: jacquard_common::CowStr<'a>,
3528}
3529
3530pub mod muted_word_state {
3531
3532 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
3533 #[allow(unused)]
3534 use ::core::marker::PhantomData;
3535 mod sealed {
3536 pub trait Sealed {}
3537 }
3538 pub trait State: sealed::Sealed {
3540 type Value;
3541 type Targets;
3542 }
3543 pub struct Empty(());
3545 impl sealed::Sealed for Empty {}
3546 impl State for Empty {
3547 type Value = Unset;
3548 type Targets = Unset;
3549 }
3550 pub struct SetValue<S: State = Empty>(PhantomData<fn() -> S>);
3552 impl<S: State> sealed::Sealed for SetValue<S> {}
3553 impl<S: State> State for SetValue<S> {
3554 type Value = Set<members::value>;
3555 type Targets = S::Targets;
3556 }
3557 pub struct SetTargets<S: State = Empty>(PhantomData<fn() -> S>);
3559 impl<S: State> sealed::Sealed for SetTargets<S> {}
3560 impl<S: State> State for SetTargets<S> {
3561 type Value = S::Value;
3562 type Targets = Set<members::targets>;
3563 }
3564 #[allow(non_camel_case_types)]
3566 pub mod members {
3567 pub struct value(());
3569 pub struct targets(());
3571 }
3572}
3573
3574pub struct MutedWordBuilder<'a, S: muted_word_state::State> {
3576 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
3577 __unsafe_private_named: (
3578 ::core::option::Option<jacquard_common::CowStr<'a>>,
3579 ::core::option::Option<jacquard_common::types::string::Datetime>,
3580 ::core::option::Option<jacquard_common::CowStr<'a>>,
3581 ::core::option::Option<Vec<crate::app_bsky::actor::MutedWordTarget<'a>>>,
3582 ::core::option::Option<jacquard_common::CowStr<'a>>,
3583 ),
3584 _phantom: ::core::marker::PhantomData<&'a ()>,
3585}
3586
3587impl<'a> MutedWord<'a> {
3588 pub fn new() -> MutedWordBuilder<'a, muted_word_state::Empty> {
3590 MutedWordBuilder::new()
3591 }
3592}
3593
3594impl<'a> MutedWordBuilder<'a, muted_word_state::Empty> {
3595 pub fn new() -> Self {
3597 MutedWordBuilder {
3598 _phantom_state: ::core::marker::PhantomData,
3599 __unsafe_private_named: (None, None, None, None, None),
3600 _phantom: ::core::marker::PhantomData,
3601 }
3602 }
3603}
3604
3605impl<'a, S: muted_word_state::State> MutedWordBuilder<'a, S> {
3606 pub fn actor_target(
3608 mut self,
3609 value: impl Into<Option<jacquard_common::CowStr<'a>>>,
3610 ) -> Self {
3611 self.__unsafe_private_named.0 = value.into();
3612 self
3613 }
3614 pub fn maybe_actor_target(
3616 mut self,
3617 value: Option<jacquard_common::CowStr<'a>>,
3618 ) -> Self {
3619 self.__unsafe_private_named.0 = value;
3620 self
3621 }
3622}
3623
3624impl<'a, S: muted_word_state::State> MutedWordBuilder<'a, S> {
3625 pub fn expires_at(
3627 mut self,
3628 value: impl Into<Option<jacquard_common::types::string::Datetime>>,
3629 ) -> Self {
3630 self.__unsafe_private_named.1 = value.into();
3631 self
3632 }
3633 pub fn maybe_expires_at(
3635 mut self,
3636 value: Option<jacquard_common::types::string::Datetime>,
3637 ) -> Self {
3638 self.__unsafe_private_named.1 = value;
3639 self
3640 }
3641}
3642
3643impl<'a, S: muted_word_state::State> MutedWordBuilder<'a, S> {
3644 pub fn id(mut self, value: impl Into<Option<jacquard_common::CowStr<'a>>>) -> Self {
3646 self.__unsafe_private_named.2 = value.into();
3647 self
3648 }
3649 pub fn maybe_id(mut self, value: Option<jacquard_common::CowStr<'a>>) -> Self {
3651 self.__unsafe_private_named.2 = value;
3652 self
3653 }
3654}
3655
3656impl<'a, S> MutedWordBuilder<'a, S>
3657where
3658 S: muted_word_state::State,
3659 S::Targets: muted_word_state::IsUnset,
3660{
3661 pub fn targets(
3663 mut self,
3664 value: impl Into<Vec<crate::app_bsky::actor::MutedWordTarget<'a>>>,
3665 ) -> MutedWordBuilder<'a, muted_word_state::SetTargets<S>> {
3666 self.__unsafe_private_named.3 = ::core::option::Option::Some(value.into());
3667 MutedWordBuilder {
3668 _phantom_state: ::core::marker::PhantomData,
3669 __unsafe_private_named: self.__unsafe_private_named,
3670 _phantom: ::core::marker::PhantomData,
3671 }
3672 }
3673}
3674
3675impl<'a, S> MutedWordBuilder<'a, S>
3676where
3677 S: muted_word_state::State,
3678 S::Value: muted_word_state::IsUnset,
3679{
3680 pub fn value(
3682 mut self,
3683 value: impl Into<jacquard_common::CowStr<'a>>,
3684 ) -> MutedWordBuilder<'a, muted_word_state::SetValue<S>> {
3685 self.__unsafe_private_named.4 = ::core::option::Option::Some(value.into());
3686 MutedWordBuilder {
3687 _phantom_state: ::core::marker::PhantomData,
3688 __unsafe_private_named: self.__unsafe_private_named,
3689 _phantom: ::core::marker::PhantomData,
3690 }
3691 }
3692}
3693
3694impl<'a, S> MutedWordBuilder<'a, S>
3695where
3696 S: muted_word_state::State,
3697 S::Value: muted_word_state::IsSet,
3698 S::Targets: muted_word_state::IsSet,
3699{
3700 pub fn build(self) -> MutedWord<'a> {
3702 MutedWord {
3703 actor_target: self.__unsafe_private_named.0,
3704 expires_at: self.__unsafe_private_named.1,
3705 id: self.__unsafe_private_named.2,
3706 targets: self.__unsafe_private_named.3.unwrap(),
3707 value: self.__unsafe_private_named.4.unwrap(),
3708 extra_data: Default::default(),
3709 }
3710 }
3711 pub fn build_with_data(
3713 self,
3714 extra_data: std::collections::BTreeMap<
3715 jacquard_common::smol_str::SmolStr,
3716 jacquard_common::types::value::Data<'a>,
3717 >,
3718 ) -> MutedWord<'a> {
3719 MutedWord {
3720 actor_target: self.__unsafe_private_named.0,
3721 expires_at: self.__unsafe_private_named.1,
3722 id: self.__unsafe_private_named.2,
3723 targets: self.__unsafe_private_named.3.unwrap(),
3724 value: self.__unsafe_private_named.4.unwrap(),
3725 extra_data: Some(extra_data),
3726 }
3727 }
3728}
3729
3730impl<'a> ::jacquard_lexicon::schema::LexiconSchema for MutedWord<'a> {
3731 fn nsid() -> &'static str {
3732 "app.bsky.actor.defs"
3733 }
3734 fn def_name() -> &'static str {
3735 "mutedWord"
3736 }
3737 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
3738 lexicon_doc_app_bsky_actor_defs()
3739 }
3740 fn validate(
3741 &self,
3742 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
3743 {
3744 let value = &self.value;
3745 #[allow(unused_comparisons)]
3746 if <str>::len(value.as_ref()) > 10000usize {
3747 return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
3748 path: ::jacquard_lexicon::validation::ValidationPath::from_field(
3749 "value",
3750 ),
3751 max: 10000usize,
3752 actual: <str>::len(value.as_ref()),
3753 });
3754 }
3755 }
3756 {
3757 let value = &self.value;
3758 {
3759 let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
3760 value.as_ref(),
3761 true,
3762 )
3763 .count();
3764 if count > 1000usize {
3765 return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes {
3766 path: ::jacquard_lexicon::validation::ValidationPath::from_field(
3767 "value",
3768 ),
3769 max: 1000usize,
3770 actual: count,
3771 });
3772 }
3773 }
3774 }
3775 Ok(())
3776 }
3777}
3778
3779#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3780pub enum MutedWordTarget<'a> {
3781 Content,
3782 Tag,
3783 Other(jacquard_common::CowStr<'a>),
3784}
3785
3786impl<'a> MutedWordTarget<'a> {
3787 pub fn as_str(&self) -> &str {
3788 match self {
3789 Self::Content => "content",
3790 Self::Tag => "tag",
3791 Self::Other(s) => s.as_ref(),
3792 }
3793 }
3794}
3795
3796impl<'a> From<&'a str> for MutedWordTarget<'a> {
3797 fn from(s: &'a str) -> Self {
3798 match s {
3799 "content" => Self::Content,
3800 "tag" => Self::Tag,
3801 _ => Self::Other(jacquard_common::CowStr::from(s)),
3802 }
3803 }
3804}
3805
3806impl<'a> From<String> for MutedWordTarget<'a> {
3807 fn from(s: String) -> Self {
3808 match s.as_str() {
3809 "content" => Self::Content,
3810 "tag" => Self::Tag,
3811 _ => Self::Other(jacquard_common::CowStr::from(s)),
3812 }
3813 }
3814}
3815
3816impl<'a> AsRef<str> for MutedWordTarget<'a> {
3817 fn as_ref(&self) -> &str {
3818 self.as_str()
3819 }
3820}
3821
3822impl<'a> serde::Serialize for MutedWordTarget<'a> {
3823 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
3824 where
3825 S: serde::Serializer,
3826 {
3827 serializer.serialize_str(self.as_str())
3828 }
3829}
3830
3831impl<'de, 'a> serde::Deserialize<'de> for MutedWordTarget<'a>
3832where
3833 'de: 'a,
3834{
3835 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
3836 where
3837 D: serde::Deserializer<'de>,
3838 {
3839 let s = <&'de str>::deserialize(deserializer)?;
3840 Ok(Self::from(s))
3841 }
3842}
3843
3844impl jacquard_common::IntoStatic for MutedWordTarget<'_> {
3845 type Output = MutedWordTarget<'static>;
3846 fn into_static(self) -> Self::Output {
3847 match self {
3848 MutedWordTarget::Content => MutedWordTarget::Content,
3849 MutedWordTarget::Tag => MutedWordTarget::Tag,
3850 MutedWordTarget::Other(v) => MutedWordTarget::Other(v.into_static()),
3851 }
3852 }
3853}
3854
3855#[jacquard_derive::lexicon]
3856#[derive(
3857 serde::Serialize,
3858 serde::Deserialize,
3859 Debug,
3860 Clone,
3861 PartialEq,
3862 Eq,
3863 jacquard_derive::IntoStatic
3864)]
3865#[serde(rename_all = "camelCase")]
3866pub struct MutedWordsPref<'a> {
3867 #[serde(borrow)]
3869 pub items: Vec<crate::app_bsky::actor::MutedWord<'a>>,
3870}
3871
3872pub mod muted_words_pref_state {
3873
3874 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
3875 #[allow(unused)]
3876 use ::core::marker::PhantomData;
3877 mod sealed {
3878 pub trait Sealed {}
3879 }
3880 pub trait State: sealed::Sealed {
3882 type Items;
3883 }
3884 pub struct Empty(());
3886 impl sealed::Sealed for Empty {}
3887 impl State for Empty {
3888 type Items = Unset;
3889 }
3890 pub struct SetItems<S: State = Empty>(PhantomData<fn() -> S>);
3892 impl<S: State> sealed::Sealed for SetItems<S> {}
3893 impl<S: State> State for SetItems<S> {
3894 type Items = Set<members::items>;
3895 }
3896 #[allow(non_camel_case_types)]
3898 pub mod members {
3899 pub struct items(());
3901 }
3902}
3903
3904pub struct MutedWordsPrefBuilder<'a, S: muted_words_pref_state::State> {
3906 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
3907 __unsafe_private_named: (
3908 ::core::option::Option<Vec<crate::app_bsky::actor::MutedWord<'a>>>,
3909 ),
3910 _phantom: ::core::marker::PhantomData<&'a ()>,
3911}
3912
3913impl<'a> MutedWordsPref<'a> {
3914 pub fn new() -> MutedWordsPrefBuilder<'a, muted_words_pref_state::Empty> {
3916 MutedWordsPrefBuilder::new()
3917 }
3918}
3919
3920impl<'a> MutedWordsPrefBuilder<'a, muted_words_pref_state::Empty> {
3921 pub fn new() -> Self {
3923 MutedWordsPrefBuilder {
3924 _phantom_state: ::core::marker::PhantomData,
3925 __unsafe_private_named: (None,),
3926 _phantom: ::core::marker::PhantomData,
3927 }
3928 }
3929}
3930
3931impl<'a, S> MutedWordsPrefBuilder<'a, S>
3932where
3933 S: muted_words_pref_state::State,
3934 S::Items: muted_words_pref_state::IsUnset,
3935{
3936 pub fn items(
3938 mut self,
3939 value: impl Into<Vec<crate::app_bsky::actor::MutedWord<'a>>>,
3940 ) -> MutedWordsPrefBuilder<'a, muted_words_pref_state::SetItems<S>> {
3941 self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
3942 MutedWordsPrefBuilder {
3943 _phantom_state: ::core::marker::PhantomData,
3944 __unsafe_private_named: self.__unsafe_private_named,
3945 _phantom: ::core::marker::PhantomData,
3946 }
3947 }
3948}
3949
3950impl<'a, S> MutedWordsPrefBuilder<'a, S>
3951where
3952 S: muted_words_pref_state::State,
3953 S::Items: muted_words_pref_state::IsSet,
3954{
3955 pub fn build(self) -> MutedWordsPref<'a> {
3957 MutedWordsPref {
3958 items: self.__unsafe_private_named.0.unwrap(),
3959 extra_data: Default::default(),
3960 }
3961 }
3962 pub fn build_with_data(
3964 self,
3965 extra_data: std::collections::BTreeMap<
3966 jacquard_common::smol_str::SmolStr,
3967 jacquard_common::types::value::Data<'a>,
3968 >,
3969 ) -> MutedWordsPref<'a> {
3970 MutedWordsPref {
3971 items: self.__unsafe_private_named.0.unwrap(),
3972 extra_data: Some(extra_data),
3973 }
3974 }
3975}
3976
3977impl<'a> ::jacquard_lexicon::schema::LexiconSchema for MutedWordsPref<'a> {
3978 fn nsid() -> &'static str {
3979 "app.bsky.actor.defs"
3980 }
3981 fn def_name() -> &'static str {
3982 "mutedWordsPref"
3983 }
3984 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
3985 lexicon_doc_app_bsky_actor_defs()
3986 }
3987 fn validate(
3988 &self,
3989 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
3990 Ok(())
3991 }
3992}
3993
3994#[jacquard_derive::lexicon]
3996#[derive(
3997 serde::Serialize,
3998 serde::Deserialize,
3999 Debug,
4000 Clone,
4001 PartialEq,
4002 Eq,
4003 jacquard_derive::IntoStatic
4004)]
4005#[serde(rename_all = "camelCase")]
4006pub struct Nux<'a> {
4007 pub completed: bool,
4008 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4010 #[serde(borrow)]
4011 pub data: Option<jacquard_common::CowStr<'a>>,
4012 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4014 pub expires_at: Option<jacquard_common::types::string::Datetime>,
4015 #[serde(borrow)]
4016 pub id: jacquard_common::CowStr<'a>,
4017}
4018
4019pub mod nux_state {
4020
4021 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
4022 #[allow(unused)]
4023 use ::core::marker::PhantomData;
4024 mod sealed {
4025 pub trait Sealed {}
4026 }
4027 pub trait State: sealed::Sealed {
4029 type Id;
4030 type Completed;
4031 }
4032 pub struct Empty(());
4034 impl sealed::Sealed for Empty {}
4035 impl State for Empty {
4036 type Id = Unset;
4037 type Completed = Unset;
4038 }
4039 pub struct SetId<S: State = Empty>(PhantomData<fn() -> S>);
4041 impl<S: State> sealed::Sealed for SetId<S> {}
4042 impl<S: State> State for SetId<S> {
4043 type Id = Set<members::id>;
4044 type Completed = S::Completed;
4045 }
4046 pub struct SetCompleted<S: State = Empty>(PhantomData<fn() -> S>);
4048 impl<S: State> sealed::Sealed for SetCompleted<S> {}
4049 impl<S: State> State for SetCompleted<S> {
4050 type Id = S::Id;
4051 type Completed = Set<members::completed>;
4052 }
4053 #[allow(non_camel_case_types)]
4055 pub mod members {
4056 pub struct id(());
4058 pub struct completed(());
4060 }
4061}
4062
4063pub struct NuxBuilder<'a, S: nux_state::State> {
4065 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
4066 __unsafe_private_named: (
4067 ::core::option::Option<bool>,
4068 ::core::option::Option<jacquard_common::CowStr<'a>>,
4069 ::core::option::Option<jacquard_common::types::string::Datetime>,
4070 ::core::option::Option<jacquard_common::CowStr<'a>>,
4071 ),
4072 _phantom: ::core::marker::PhantomData<&'a ()>,
4073}
4074
4075impl<'a> Nux<'a> {
4076 pub fn new() -> NuxBuilder<'a, nux_state::Empty> {
4078 NuxBuilder::new()
4079 }
4080}
4081
4082impl<'a> NuxBuilder<'a, nux_state::Empty> {
4083 pub fn new() -> Self {
4085 NuxBuilder {
4086 _phantom_state: ::core::marker::PhantomData,
4087 __unsafe_private_named: (None, None, None, None),
4088 _phantom: ::core::marker::PhantomData,
4089 }
4090 }
4091}
4092
4093impl<'a, S> NuxBuilder<'a, S>
4094where
4095 S: nux_state::State,
4096 S::Completed: nux_state::IsUnset,
4097{
4098 pub fn completed(
4100 mut self,
4101 value: impl Into<bool>,
4102 ) -> NuxBuilder<'a, nux_state::SetCompleted<S>> {
4103 self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
4104 NuxBuilder {
4105 _phantom_state: ::core::marker::PhantomData,
4106 __unsafe_private_named: self.__unsafe_private_named,
4107 _phantom: ::core::marker::PhantomData,
4108 }
4109 }
4110}
4111
4112impl<'a, S: nux_state::State> NuxBuilder<'a, S> {
4113 pub fn data(
4115 mut self,
4116 value: impl Into<Option<jacquard_common::CowStr<'a>>>,
4117 ) -> Self {
4118 self.__unsafe_private_named.1 = value.into();
4119 self
4120 }
4121 pub fn maybe_data(mut self, value: Option<jacquard_common::CowStr<'a>>) -> Self {
4123 self.__unsafe_private_named.1 = value;
4124 self
4125 }
4126}
4127
4128impl<'a, S: nux_state::State> NuxBuilder<'a, S> {
4129 pub fn expires_at(
4131 mut self,
4132 value: impl Into<Option<jacquard_common::types::string::Datetime>>,
4133 ) -> Self {
4134 self.__unsafe_private_named.2 = value.into();
4135 self
4136 }
4137 pub fn maybe_expires_at(
4139 mut self,
4140 value: Option<jacquard_common::types::string::Datetime>,
4141 ) -> Self {
4142 self.__unsafe_private_named.2 = value;
4143 self
4144 }
4145}
4146
4147impl<'a, S> NuxBuilder<'a, S>
4148where
4149 S: nux_state::State,
4150 S::Id: nux_state::IsUnset,
4151{
4152 pub fn id(
4154 mut self,
4155 value: impl Into<jacquard_common::CowStr<'a>>,
4156 ) -> NuxBuilder<'a, nux_state::SetId<S>> {
4157 self.__unsafe_private_named.3 = ::core::option::Option::Some(value.into());
4158 NuxBuilder {
4159 _phantom_state: ::core::marker::PhantomData,
4160 __unsafe_private_named: self.__unsafe_private_named,
4161 _phantom: ::core::marker::PhantomData,
4162 }
4163 }
4164}
4165
4166impl<'a, S> NuxBuilder<'a, S>
4167where
4168 S: nux_state::State,
4169 S::Id: nux_state::IsSet,
4170 S::Completed: nux_state::IsSet,
4171{
4172 pub fn build(self) -> Nux<'a> {
4174 Nux {
4175 completed: self.__unsafe_private_named.0.unwrap(),
4176 data: self.__unsafe_private_named.1,
4177 expires_at: self.__unsafe_private_named.2,
4178 id: self.__unsafe_private_named.3.unwrap(),
4179 extra_data: Default::default(),
4180 }
4181 }
4182 pub fn build_with_data(
4184 self,
4185 extra_data: std::collections::BTreeMap<
4186 jacquard_common::smol_str::SmolStr,
4187 jacquard_common::types::value::Data<'a>,
4188 >,
4189 ) -> Nux<'a> {
4190 Nux {
4191 completed: self.__unsafe_private_named.0.unwrap(),
4192 data: self.__unsafe_private_named.1,
4193 expires_at: self.__unsafe_private_named.2,
4194 id: self.__unsafe_private_named.3.unwrap(),
4195 extra_data: Some(extra_data),
4196 }
4197 }
4198}
4199
4200impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Nux<'a> {
4201 fn nsid() -> &'static str {
4202 "app.bsky.actor.defs"
4203 }
4204 fn def_name() -> &'static str {
4205 "nux"
4206 }
4207 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
4208 lexicon_doc_app_bsky_actor_defs()
4209 }
4210 fn validate(
4211 &self,
4212 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
4213 if let Some(ref value) = self.data {
4214 #[allow(unused_comparisons)]
4215 if <str>::len(value.as_ref()) > 3000usize {
4216 return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
4217 path: ::jacquard_lexicon::validation::ValidationPath::from_field(
4218 "data",
4219 ),
4220 max: 3000usize,
4221 actual: <str>::len(value.as_ref()),
4222 });
4223 }
4224 }
4225 if let Some(ref value) = self.data {
4226 {
4227 let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
4228 value.as_ref(),
4229 true,
4230 )
4231 .count();
4232 if count > 300usize {
4233 return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes {
4234 path: ::jacquard_lexicon::validation::ValidationPath::from_field(
4235 "data",
4236 ),
4237 max: 300usize,
4238 actual: count,
4239 });
4240 }
4241 }
4242 }
4243 {
4244 let value = &self.id;
4245 #[allow(unused_comparisons)]
4246 if <str>::len(value.as_ref()) > 100usize {
4247 return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
4248 path: ::jacquard_lexicon::validation::ValidationPath::from_field(
4249 "id",
4250 ),
4251 max: 100usize,
4252 actual: <str>::len(value.as_ref()),
4253 });
4254 }
4255 }
4256 Ok(())
4257 }
4258}
4259
4260#[jacquard_derive::lexicon]
4261#[derive(
4262 serde::Serialize,
4263 serde::Deserialize,
4264 Debug,
4265 Clone,
4266 PartialEq,
4267 Eq,
4268 jacquard_derive::IntoStatic,
4269 Default
4270)]
4271#[serde(rename_all = "camelCase")]
4272pub struct PersonalDetailsPref<'a> {
4273 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4275 pub birth_date: std::option::Option<jacquard_common::types::string::Datetime>,
4276}
4277
4278impl<'a> ::jacquard_lexicon::schema::LexiconSchema for PersonalDetailsPref<'a> {
4279 fn nsid() -> &'static str {
4280 "app.bsky.actor.defs"
4281 }
4282 fn def_name() -> &'static str {
4283 "personalDetailsPref"
4284 }
4285 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
4286 lexicon_doc_app_bsky_actor_defs()
4287 }
4288 fn validate(
4289 &self,
4290 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
4291 Ok(())
4292 }
4293}
4294
4295#[jacquard_derive::lexicon]
4297#[derive(
4298 serde::Serialize,
4299 serde::Deserialize,
4300 Debug,
4301 Clone,
4302 PartialEq,
4303 Eq,
4304 jacquard_derive::IntoStatic,
4305 Default
4306)]
4307#[serde(rename_all = "camelCase")]
4308pub struct PostInteractionSettingsPref<'a> {
4309 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4311 #[serde(borrow)]
4312 pub postgate_embedding_rules: std::option::Option<
4313 Vec<crate::app_bsky::feed::postgate::DisableRule<'a>>,
4314 >,
4315 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4317 #[serde(borrow)]
4318 pub threadgate_allow_rules: std::option::Option<
4319 Vec<PostInteractionSettingsPrefThreadgateAllowRulesItem<'a>>,
4320 >,
4321}
4322
4323#[jacquard_derive::open_union]
4324#[derive(
4325 serde::Serialize,
4326 serde::Deserialize,
4327 Debug,
4328 Clone,
4329 PartialEq,
4330 Eq,
4331 jacquard_derive::IntoStatic
4332)]
4333#[serde(tag = "$type")]
4334#[serde(bound(deserialize = "'de: 'a"))]
4335pub enum PostInteractionSettingsPrefThreadgateAllowRulesItem<'a> {
4336 #[serde(rename = "app.bsky.feed.threadgate#mentionRule")]
4337 ThreadgateMentionRule(Box<crate::app_bsky::feed::threadgate::MentionRule<'a>>),
4338 #[serde(rename = "app.bsky.feed.threadgate#followerRule")]
4339 ThreadgateFollowerRule(Box<crate::app_bsky::feed::threadgate::FollowerRule<'a>>),
4340 #[serde(rename = "app.bsky.feed.threadgate#followingRule")]
4341 ThreadgateFollowingRule(Box<crate::app_bsky::feed::threadgate::FollowingRule<'a>>),
4342 #[serde(rename = "app.bsky.feed.threadgate#listRule")]
4343 ThreadgateListRule(Box<crate::app_bsky::feed::threadgate::ListRule<'a>>),
4344}
4345
4346impl<'a> ::jacquard_lexicon::schema::LexiconSchema for PostInteractionSettingsPref<'a> {
4347 fn nsid() -> &'static str {
4348 "app.bsky.actor.defs"
4349 }
4350 fn def_name() -> &'static str {
4351 "postInteractionSettingsPref"
4352 }
4353 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
4354 lexicon_doc_app_bsky_actor_defs()
4355 }
4356 fn validate(
4357 &self,
4358 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
4359 if let Some(ref value) = self.postgate_embedding_rules {
4360 #[allow(unused_comparisons)]
4361 if value.len() > 5usize {
4362 return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
4363 path: ::jacquard_lexicon::validation::ValidationPath::from_field(
4364 "postgate_embedding_rules",
4365 ),
4366 max: 5usize,
4367 actual: value.len(),
4368 });
4369 }
4370 }
4371 if let Some(ref value) = self.threadgate_allow_rules {
4372 #[allow(unused_comparisons)]
4373 if value.len() > 5usize {
4374 return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
4375 path: ::jacquard_lexicon::validation::ValidationPath::from_field(
4376 "threadgate_allow_rules",
4377 ),
4378 max: 5usize,
4379 actual: value.len(),
4380 });
4381 }
4382 }
4383 Ok(())
4384 }
4385}
4386
4387#[jacquard_derive::open_union]
4388#[derive(
4389 serde::Serialize,
4390 serde::Deserialize,
4391 Debug,
4392 Clone,
4393 PartialEq,
4394 Eq,
4395 jacquard_derive::IntoStatic
4396)]
4397#[serde(tag = "$type")]
4398#[serde(bound(deserialize = "'de: 'a"))]
4399pub enum PreferencesItem<'a> {
4400 #[serde(rename = "app.bsky.actor.defs#adultContentPref")]
4401 AdultContentPref(Box<crate::app_bsky::actor::AdultContentPref<'a>>),
4402 #[serde(rename = "app.bsky.actor.defs#contentLabelPref")]
4403 ContentLabelPref(Box<crate::app_bsky::actor::ContentLabelPref<'a>>),
4404 #[serde(rename = "app.bsky.actor.defs#savedFeedsPref")]
4405 SavedFeedsPref(Box<crate::app_bsky::actor::SavedFeedsPref<'a>>),
4406 #[serde(rename = "app.bsky.actor.defs#savedFeedsPrefV2")]
4407 SavedFeedsPrefV2(Box<crate::app_bsky::actor::SavedFeedsPrefV2<'a>>),
4408 #[serde(rename = "app.bsky.actor.defs#personalDetailsPref")]
4409 PersonalDetailsPref(Box<crate::app_bsky::actor::PersonalDetailsPref<'a>>),
4410 #[serde(rename = "app.bsky.actor.defs#feedViewPref")]
4411 FeedViewPref(Box<crate::app_bsky::actor::FeedViewPref<'a>>),
4412 #[serde(rename = "app.bsky.actor.defs#threadViewPref")]
4413 ThreadViewPref(Box<crate::app_bsky::actor::ThreadViewPref<'a>>),
4414 #[serde(rename = "app.bsky.actor.defs#interestsPref")]
4415 InterestsPref(Box<crate::app_bsky::actor::InterestsPref<'a>>),
4416 #[serde(rename = "app.bsky.actor.defs#mutedWordsPref")]
4417 MutedWordsPref(Box<crate::app_bsky::actor::MutedWordsPref<'a>>),
4418 #[serde(rename = "app.bsky.actor.defs#hiddenPostsPref")]
4419 HiddenPostsPref(Box<crate::app_bsky::actor::HiddenPostsPref<'a>>),
4420 #[serde(rename = "app.bsky.actor.defs#bskyAppStatePref")]
4421 BskyAppStatePref(Box<crate::app_bsky::actor::BskyAppStatePref<'a>>),
4422 #[serde(rename = "app.bsky.actor.defs#labelersPref")]
4423 LabelersPref(Box<crate::app_bsky::actor::LabelersPref<'a>>),
4424 #[serde(rename = "app.bsky.actor.defs#postInteractionSettingsPref")]
4425 PostInteractionSettingsPref(
4426 Box<crate::app_bsky::actor::PostInteractionSettingsPref<'a>>,
4427 ),
4428 #[serde(rename = "app.bsky.actor.defs#verificationPrefs")]
4429 VerificationPrefs(Box<crate::app_bsky::actor::VerificationPrefs<'a>>),
4430}
4431
4432pub type Preferences<'a> = Vec<PreferencesItem<'a>>;
4433#[jacquard_derive::lexicon]
4434#[derive(
4435 serde::Serialize,
4436 serde::Deserialize,
4437 Debug,
4438 Clone,
4439 PartialEq,
4440 Eq,
4441 jacquard_derive::IntoStatic,
4442 Default
4443)]
4444#[serde(rename_all = "camelCase")]
4445pub struct ProfileAssociated<'a> {
4446 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4447 #[serde(borrow)]
4448 pub activity_subscription: std::option::Option<
4449 crate::app_bsky::actor::ProfileAssociatedActivitySubscription<'a>,
4450 >,
4451 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4452 #[serde(borrow)]
4453 pub chat: std::option::Option<crate::app_bsky::actor::ProfileAssociatedChat<'a>>,
4454 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4455 pub feedgens: std::option::Option<i64>,
4456 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4457 pub labeler: std::option::Option<bool>,
4458 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4459 pub lists: std::option::Option<i64>,
4460 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4461 pub starter_packs: std::option::Option<i64>,
4462}
4463
4464impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ProfileAssociated<'a> {
4465 fn nsid() -> &'static str {
4466 "app.bsky.actor.defs"
4467 }
4468 fn def_name() -> &'static str {
4469 "profileAssociated"
4470 }
4471 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
4472 lexicon_doc_app_bsky_actor_defs()
4473 }
4474 fn validate(
4475 &self,
4476 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
4477 Ok(())
4478 }
4479}
4480
4481#[jacquard_derive::lexicon]
4482#[derive(
4483 serde::Serialize,
4484 serde::Deserialize,
4485 Debug,
4486 Clone,
4487 PartialEq,
4488 Eq,
4489 jacquard_derive::IntoStatic,
4490 Default
4491)]
4492#[serde(rename_all = "camelCase")]
4493pub struct ProfileAssociatedActivitySubscription<'a> {
4494 #[serde(borrow)]
4495 pub allow_subscriptions: jacquard_common::CowStr<'a>,
4496}
4497
4498impl<'a> ::jacquard_lexicon::schema::LexiconSchema
4499for ProfileAssociatedActivitySubscription<'a> {
4500 fn nsid() -> &'static str {
4501 "app.bsky.actor.defs"
4502 }
4503 fn def_name() -> &'static str {
4504 "profileAssociatedActivitySubscription"
4505 }
4506 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
4507 lexicon_doc_app_bsky_actor_defs()
4508 }
4509 fn validate(
4510 &self,
4511 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
4512 Ok(())
4513 }
4514}
4515
4516#[jacquard_derive::lexicon]
4517#[derive(
4518 serde::Serialize,
4519 serde::Deserialize,
4520 Debug,
4521 Clone,
4522 PartialEq,
4523 Eq,
4524 jacquard_derive::IntoStatic,
4525 Default
4526)]
4527#[serde(rename_all = "camelCase")]
4528pub struct ProfileAssociatedChat<'a> {
4529 #[serde(borrow)]
4530 pub allow_incoming: jacquard_common::CowStr<'a>,
4531}
4532
4533impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ProfileAssociatedChat<'a> {
4534 fn nsid() -> &'static str {
4535 "app.bsky.actor.defs"
4536 }
4537 fn def_name() -> &'static str {
4538 "profileAssociatedChat"
4539 }
4540 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
4541 lexicon_doc_app_bsky_actor_defs()
4542 }
4543 fn validate(
4544 &self,
4545 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
4546 Ok(())
4547 }
4548}
4549
4550#[jacquard_derive::lexicon]
4551#[derive(
4552 serde::Serialize,
4553 serde::Deserialize,
4554 Debug,
4555 Clone,
4556 PartialEq,
4557 Eq,
4558 jacquard_derive::IntoStatic
4559)]
4560#[serde(rename_all = "camelCase")]
4561pub struct ProfileView<'a> {
4562 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4563 #[serde(borrow)]
4564 pub associated: Option<crate::app_bsky::actor::ProfileAssociated<'a>>,
4565 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4566 #[serde(borrow)]
4567 pub avatar: Option<jacquard_common::types::string::Uri<'a>>,
4568 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4569 pub created_at: Option<jacquard_common::types::string::Datetime>,
4570 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4572 #[serde(borrow)]
4573 pub debug: Option<jacquard_common::types::value::Data<'a>>,
4574 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4575 #[serde(borrow)]
4576 pub description: Option<jacquard_common::CowStr<'a>>,
4577 #[serde(borrow)]
4578 pub did: jacquard_common::types::string::Did<'a>,
4579 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4580 #[serde(borrow)]
4581 pub display_name: Option<jacquard_common::CowStr<'a>>,
4582 #[serde(borrow)]
4583 pub handle: jacquard_common::types::string::Handle<'a>,
4584 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4585 pub indexed_at: Option<jacquard_common::types::string::Datetime>,
4586 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4587 #[serde(borrow)]
4588 pub labels: Option<Vec<crate::com_atproto::label::Label<'a>>>,
4589 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4590 #[serde(borrow)]
4591 pub pronouns: Option<jacquard_common::CowStr<'a>>,
4592 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4593 #[serde(borrow)]
4594 pub status: Option<crate::app_bsky::actor::StatusView<'a>>,
4595 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4596 #[serde(borrow)]
4597 pub verification: Option<crate::app_bsky::actor::VerificationState<'a>>,
4598 #[serde(skip_serializing_if = "std::option::Option::is_none")]
4599 #[serde(borrow)]
4600 pub viewer: Option<crate::app_bsky::actor::ViewerState<'a>>,
4601}
4602
4603pub mod profile_view_state {
4604
4605 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
4606 #[allow(unused)]
4607 use ::core::marker::PhantomData;
4608 mod sealed {
4609 pub trait Sealed {}
4610 }
4611 pub trait State: sealed::Sealed {
4613 type Did;
4614 type Handle;
4615 }
4616 pub struct Empty(());
4618 impl sealed::Sealed for Empty {}
4619 impl State for Empty {
4620 type Did = Unset;
4621 type Handle = Unset;
4622 }
4623 pub struct SetDid<S: State = Empty>(PhantomData<fn() -> S>);
4625 impl<S: State> sealed::Sealed for SetDid<S> {}
4626 impl<S: State> State for SetDid<S> {
4627 type Did = Set<members::did>;
4628 type Handle = S::Handle;
4629 }
4630 pub struct SetHandle<S: State = Empty>(PhantomData<fn() -> S>);
4632 impl<S: State> sealed::Sealed for SetHandle<S> {}
4633 impl<S: State> State for SetHandle<S> {
4634 type Did = S::Did;
4635 type Handle = Set<members::handle>;
4636 }
4637 #[allow(non_camel_case_types)]
4639 pub mod members {
4640 pub struct did(());
4642 pub struct handle(());
4644 }
4645}
4646
4647pub struct ProfileViewBuilder<'a, S: profile_view_state::State> {
4649 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
4650 __unsafe_private_named: (
4651 ::core::option::Option<crate::app_bsky::actor::ProfileAssociated<'a>>,
4652 ::core::option::Option<jacquard_common::types::string::Uri<'a>>,
4653 ::core::option::Option<jacquard_common::types::string::Datetime>,
4654 ::core::option::Option<jacquard_common::types::value::Data<'a>>,
4655 ::core::option::Option<jacquard_common::CowStr<'a>>,
4656 ::core::option::Option<jacquard_common::types::string::Did<'a>>,
4657 ::core::option::Option<jacquard_common::CowStr<'a>>,
4658 ::core::option::Option<jacquard_common::types::string::Handle<'a>>,
4659 ::core::option::Option<jacquard_common::types::string::Datetime>,
4660 ::core::option::Option<Vec<crate::com_atproto::label::Label<'a>>>,
4661 ::core::option::Option<jacquard_common::CowStr<'a>>,
4662 ::core::option::Option<crate::app_bsky::actor::StatusView<'a>>,
4663 ::core::option::Option<crate::app_bsky::actor::VerificationState<'a>>,
4664 ::core::option::Option<crate::app_bsky::actor::ViewerState<'a>>,
4665 ),
4666 _phantom: ::core::marker::PhantomData<&'a ()>,
4667}
4668
4669impl<'a> ProfileView<'a> {
4670 pub fn new() -> ProfileViewBuilder<'a, profile_view_state::Empty> {
4672 ProfileViewBuilder::new()
4673 }
4674}
4675
4676impl<'a> ProfileViewBuilder<'a, profile_view_state::Empty> {
4677 pub fn new() -> Self {
4679 ProfileViewBuilder {
4680 _phantom_state: ::core::marker::PhantomData,
4681 __unsafe_private_named: (
4682 None,
4683 None,
4684 None,
4685 None,
4686 None,
4687 None,
4688 None,
4689 None,
4690 None,
4691 None,
4692 None,
4693 None,
4694 None,
4695 None,
4696 ),
4697 _phantom: ::core::marker::PhantomData,
4698 }
4699 }
4700}
4701
4702impl<'a, S: profile_view_state::State> ProfileViewBuilder<'a, S> {
4703 pub fn associated(
4705 mut self,
4706 value: impl Into<Option<crate::app_bsky::actor::ProfileAssociated<'a>>>,
4707 ) -> Self {
4708 self.__unsafe_private_named.0 = value.into();
4709 self
4710 }
4711 pub fn maybe_associated(
4713 mut self,
4714 value: Option<crate::app_bsky::actor::ProfileAssociated<'a>>,
4715 ) -> Self {
4716 self.__unsafe_private_named.0 = value;
4717 self
4718 }
4719}
4720
4721impl<'a, S: profile_view_state::State> ProfileViewBuilder<'a, S> {
4722 pub fn avatar(
4724 mut self,
4725 value: impl Into<Option<jacquard_common::types::string::Uri<'a>>>,
4726 ) -> Self {
4727 self.__unsafe_private_named.1 = value.into();
4728 self
4729 }
4730 pub fn maybe_avatar(
4732 mut self,
4733 value: Option<jacquard_common::types::string::Uri<'a>>,
4734 ) -> Self {
4735 self.__unsafe_private_named.1 = value;
4736 self
4737 }
4738}
4739
4740impl<'a, S: profile_view_state::State> ProfileViewBuilder<'a, S> {
4741 pub fn created_at(
4743 mut self,
4744 value: impl Into<Option<jacquard_common::types::string::Datetime>>,
4745 ) -> Self {
4746 self.__unsafe_private_named.2 = value.into();
4747 self
4748 }
4749 pub fn maybe_created_at(
4751 mut self,
4752 value: Option<jacquard_common::types::string::Datetime>,
4753 ) -> Self {
4754 self.__unsafe_private_named.2 = value;
4755 self
4756 }
4757}
4758
4759impl<'a, S: profile_view_state::State> ProfileViewBuilder<'a, S> {
4760 pub fn debug(
4762 mut self,
4763 value: impl Into<Option<jacquard_common::types::value::Data<'a>>>,
4764 ) -> Self {
4765 self.__unsafe_private_named.3 = value.into();
4766 self
4767 }
4768 pub fn maybe_debug(
4770 mut self,
4771 value: Option<jacquard_common::types::value::Data<'a>>,
4772 ) -> Self {
4773 self.__unsafe_private_named.3 = value;
4774 self
4775 }
4776}
4777
4778impl<'a, S: profile_view_state::State> ProfileViewBuilder<'a, S> {
4779 pub fn description(
4781 mut self,
4782 value: impl Into<Option<jacquard_common::CowStr<'a>>>,
4783 ) -> Self {
4784 self.__unsafe_private_named.4 = value.into();
4785 self
4786 }
4787 pub fn maybe_description(
4789 mut self,
4790 value: Option<jacquard_common::CowStr<'a>>,
4791 ) -> Self {
4792 self.__unsafe_private_named.4 = value;
4793 self
4794 }
4795}
4796
4797impl<'a, S> ProfileViewBuilder<'a, S>
4798where
4799 S: profile_view_state::State,
4800 S::Did: profile_view_state::IsUnset,
4801{
4802 pub fn did(
4804 mut self,
4805 value: impl Into<jacquard_common::types::string::Did<'a>>,
4806 ) -> ProfileViewBuilder<'a, profile_view_state::SetDid<S>> {
4807 self.__unsafe_private_named.5 = ::core::option::Option::Some(value.into());
4808 ProfileViewBuilder {
4809 _phantom_state: ::core::marker::PhantomData,
4810 __unsafe_private_named: self.__unsafe_private_named,
4811 _phantom: ::core::marker::PhantomData,
4812 }
4813 }
4814}
4815
4816impl<'a, S: profile_view_state::State> ProfileViewBuilder<'a, S> {
4817 pub fn display_name(
4819 mut self,
4820 value: impl Into<Option<jacquard_common::CowStr<'a>>>,
4821 ) -> Self {
4822 self.__unsafe_private_named.6 = value.into();
4823 self
4824 }
4825 pub fn maybe_display_name(
4827 mut self,
4828 value: Option<jacquard_common::CowStr<'a>>,
4829 ) -> Self {
4830 self.__unsafe_private_named.6 = value;
4831 self
4832 }
4833}
4834
4835impl<'a, S> ProfileViewBuilder<'a, S>
4836where
4837 S: profile_view_state::State,
4838 S::Handle: profile_view_state::IsUnset,
4839{
4840 pub fn handle(
4842 mut self,
4843 value: impl Into<jacquard_common::types::string::Handle<'a>>,
4844 ) -> ProfileViewBuilder<'a, profile_view_state::SetHandle<S>> {
4845 self.__unsafe_private_named.7 = ::core::option::Option::Some(value.into());
4846 ProfileViewBuilder {
4847 _phantom_state: ::core::marker::PhantomData,
4848 __unsafe_private_named: self.__unsafe_private_named,
4849 _phantom: ::core::marker::PhantomData,
4850 }
4851 }
4852}
4853
4854impl<'a, S: profile_view_state::State> ProfileViewBuilder<'a, S> {
4855 pub fn indexed_at(
4857 mut self,
4858 value: impl Into<Option<jacquard_common::types::string::Datetime>>,
4859 ) -> Self {
4860 self.__unsafe_private_named.8 = value.into();
4861 self
4862 }
4863 pub fn maybe_indexed_at(
4865 mut self,
4866 value: Option<jacquard_common::types::string::Datetime>,
4867 ) -> Self {
4868 self.__unsafe_private_named.8 = value;
4869 self
4870 }
4871}
4872
4873impl<'a, S: profile_view_state::State> ProfileViewBuilder<'a, S> {
4874 pub fn labels(
4876 mut self,
4877 value: impl Into<Option<Vec<crate::com_atproto::label::Label<'a>>>>,
4878 ) -> Self {
4879 self.__unsafe_private_named.9 = value.into();
4880 self
4881 }
4882 pub fn maybe_labels(
4884 mut self,
4885 value: Option<Vec<crate::com_atproto::label::Label<'a>>>,
4886 ) -> Self {
4887 self.__unsafe_private_named.9 = value;
4888 self
4889 }
4890}
4891
4892impl<'a, S: profile_view_state::State> ProfileViewBuilder<'a, S> {
4893 pub fn pronouns(
4895 mut self,
4896 value: impl Into<Option<jacquard_common::CowStr<'a>>>,
4897 ) -> Self {
4898 self.__unsafe_private_named.10 = value.into();
4899 self
4900 }
4901 pub fn maybe_pronouns(mut self, value: Option<jacquard_common::CowStr<'a>>) -> Self {
4903 self.__unsafe_private_named.10 = value;
4904 self
4905 }
4906}
4907
4908impl<'a, S: profile_view_state::State> ProfileViewBuilder<'a, S> {
4909 pub fn status(
4911 mut self,
4912 value: impl Into<Option<crate::app_bsky::actor::StatusView<'a>>>,
4913 ) -> Self {
4914 self.__unsafe_private_named.11 = value.into();
4915 self
4916 }
4917 pub fn maybe_status(
4919 mut self,
4920 value: Option<crate::app_bsky::actor::StatusView<'a>>,
4921 ) -> Self {
4922 self.__unsafe_private_named.11 = value;
4923 self
4924 }
4925}
4926
4927impl<'a, S: profile_view_state::State> ProfileViewBuilder<'a, S> {
4928 pub fn verification(
4930 mut self,
4931 value: impl Into<Option<crate::app_bsky::actor::VerificationState<'a>>>,
4932 ) -> Self {
4933 self.__unsafe_private_named.12 = value.into();
4934 self
4935 }
4936 pub fn maybe_verification(
4938 mut self,
4939 value: Option<crate::app_bsky::actor::VerificationState<'a>>,
4940 ) -> Self {
4941 self.__unsafe_private_named.12 = value;
4942 self
4943 }
4944}
4945
4946impl<'a, S: profile_view_state::State> ProfileViewBuilder<'a, S> {
4947 pub fn viewer(
4949 mut self,
4950 value: impl Into<Option<crate::app_bsky::actor::ViewerState<'a>>>,
4951 ) -> Self {
4952 self.__unsafe_private_named.13 = value.into();
4953 self
4954 }
4955 pub fn maybe_viewer(
4957 mut self,
4958 value: Option<crate::app_bsky::actor::ViewerState<'a>>,
4959 ) -> Self {
4960 self.__unsafe_private_named.13 = value;
4961 self
4962 }
4963}
4964
4965impl<'a, S> ProfileViewBuilder<'a, S>
4966where
4967 S: profile_view_state::State,
4968 S::Did: profile_view_state::IsSet,
4969 S::Handle: profile_view_state::IsSet,
4970{
4971 pub fn build(self) -> ProfileView<'a> {
4973 ProfileView {
4974 associated: self.__unsafe_private_named.0,
4975 avatar: self.__unsafe_private_named.1,
4976 created_at: self.__unsafe_private_named.2,
4977 debug: self.__unsafe_private_named.3,
4978 description: self.__unsafe_private_named.4,
4979 did: self.__unsafe_private_named.5.unwrap(),
4980 display_name: self.__unsafe_private_named.6,
4981 handle: self.__unsafe_private_named.7.unwrap(),
4982 indexed_at: self.__unsafe_private_named.8,
4983 labels: self.__unsafe_private_named.9,
4984 pronouns: self.__unsafe_private_named.10,
4985 status: self.__unsafe_private_named.11,
4986 verification: self.__unsafe_private_named.12,
4987 viewer: self.__unsafe_private_named.13,
4988 extra_data: Default::default(),
4989 }
4990 }
4991 pub fn build_with_data(
4993 self,
4994 extra_data: std::collections::BTreeMap<
4995 jacquard_common::smol_str::SmolStr,
4996 jacquard_common::types::value::Data<'a>,
4997 >,
4998 ) -> ProfileView<'a> {
4999 ProfileView {
5000 associated: self.__unsafe_private_named.0,
5001 avatar: self.__unsafe_private_named.1,
5002 created_at: self.__unsafe_private_named.2,
5003 debug: self.__unsafe_private_named.3,
5004 description: self.__unsafe_private_named.4,
5005 did: self.__unsafe_private_named.5.unwrap(),
5006 display_name: self.__unsafe_private_named.6,
5007 handle: self.__unsafe_private_named.7.unwrap(),
5008 indexed_at: self.__unsafe_private_named.8,
5009 labels: self.__unsafe_private_named.9,
5010 pronouns: self.__unsafe_private_named.10,
5011 status: self.__unsafe_private_named.11,
5012 verification: self.__unsafe_private_named.12,
5013 viewer: self.__unsafe_private_named.13,
5014 extra_data: Some(extra_data),
5015 }
5016 }
5017}
5018
5019impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ProfileView<'a> {
5020 fn nsid() -> &'static str {
5021 "app.bsky.actor.defs"
5022 }
5023 fn def_name() -> &'static str {
5024 "profileView"
5025 }
5026 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
5027 lexicon_doc_app_bsky_actor_defs()
5028 }
5029 fn validate(
5030 &self,
5031 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
5032 if let Some(ref value) = self.description {
5033 #[allow(unused_comparisons)]
5034 if <str>::len(value.as_ref()) > 2560usize {
5035 return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
5036 path: ::jacquard_lexicon::validation::ValidationPath::from_field(
5037 "description",
5038 ),
5039 max: 2560usize,
5040 actual: <str>::len(value.as_ref()),
5041 });
5042 }
5043 }
5044 if let Some(ref value) = self.description {
5045 {
5046 let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
5047 value.as_ref(),
5048 true,
5049 )
5050 .count();
5051 if count > 256usize {
5052 return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes {
5053 path: ::jacquard_lexicon::validation::ValidationPath::from_field(
5054 "description",
5055 ),
5056 max: 256usize,
5057 actual: count,
5058 });
5059 }
5060 }
5061 }
5062 if let Some(ref value) = self.display_name {
5063 #[allow(unused_comparisons)]
5064 if <str>::len(value.as_ref()) > 640usize {
5065 return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
5066 path: ::jacquard_lexicon::validation::ValidationPath::from_field(
5067 "display_name",
5068 ),
5069 max: 640usize,
5070 actual: <str>::len(value.as_ref()),
5071 });
5072 }
5073 }
5074 if let Some(ref value) = self.display_name {
5075 {
5076 let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
5077 value.as_ref(),
5078 true,
5079 )
5080 .count();
5081 if count > 64usize {
5082 return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes {
5083 path: ::jacquard_lexicon::validation::ValidationPath::from_field(
5084 "display_name",
5085 ),
5086 max: 64usize,
5087 actual: count,
5088 });
5089 }
5090 }
5091 }
5092 Ok(())
5093 }
5094}
5095
5096#[jacquard_derive::lexicon]
5097#[derive(
5098 serde::Serialize,
5099 serde::Deserialize,
5100 Debug,
5101 Clone,
5102 PartialEq,
5103 Eq,
5104 jacquard_derive::IntoStatic
5105)]
5106#[serde(rename_all = "camelCase")]
5107pub struct ProfileViewBasic<'a> {
5108 #[serde(skip_serializing_if = "std::option::Option::is_none")]
5109 #[serde(borrow)]
5110 pub associated: Option<crate::app_bsky::actor::ProfileAssociated<'a>>,
5111 #[serde(skip_serializing_if = "std::option::Option::is_none")]
5112 #[serde(borrow)]
5113 pub avatar: Option<jacquard_common::types::string::Uri<'a>>,
5114 #[serde(skip_serializing_if = "std::option::Option::is_none")]
5115 pub created_at: Option<jacquard_common::types::string::Datetime>,
5116 #[serde(skip_serializing_if = "std::option::Option::is_none")]
5118 #[serde(borrow)]
5119 pub debug: Option<jacquard_common::types::value::Data<'a>>,
5120 #[serde(borrow)]
5121 pub did: jacquard_common::types::string::Did<'a>,
5122 #[serde(skip_serializing_if = "std::option::Option::is_none")]
5123 #[serde(borrow)]
5124 pub display_name: Option<jacquard_common::CowStr<'a>>,
5125 #[serde(borrow)]
5126 pub handle: jacquard_common::types::string::Handle<'a>,
5127 #[serde(skip_serializing_if = "std::option::Option::is_none")]
5128 #[serde(borrow)]
5129 pub labels: Option<Vec<crate::com_atproto::label::Label<'a>>>,
5130 #[serde(skip_serializing_if = "std::option::Option::is_none")]
5131 #[serde(borrow)]
5132 pub pronouns: Option<jacquard_common::CowStr<'a>>,
5133 #[serde(skip_serializing_if = "std::option::Option::is_none")]
5134 #[serde(borrow)]
5135 pub status: Option<crate::app_bsky::actor::StatusView<'a>>,
5136 #[serde(skip_serializing_if = "std::option::Option::is_none")]
5137 #[serde(borrow)]
5138 pub verification: Option<crate::app_bsky::actor::VerificationState<'a>>,
5139 #[serde(skip_serializing_if = "std::option::Option::is_none")]
5140 #[serde(borrow)]
5141 pub viewer: Option<crate::app_bsky::actor::ViewerState<'a>>,
5142}
5143
5144pub mod profile_view_basic_state {
5145
5146 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
5147 #[allow(unused)]
5148 use ::core::marker::PhantomData;
5149 mod sealed {
5150 pub trait Sealed {}
5151 }
5152 pub trait State: sealed::Sealed {
5154 type Did;
5155 type Handle;
5156 }
5157 pub struct Empty(());
5159 impl sealed::Sealed for Empty {}
5160 impl State for Empty {
5161 type Did = Unset;
5162 type Handle = Unset;
5163 }
5164 pub struct SetDid<S: State = Empty>(PhantomData<fn() -> S>);
5166 impl<S: State> sealed::Sealed for SetDid<S> {}
5167 impl<S: State> State for SetDid<S> {
5168 type Did = Set<members::did>;
5169 type Handle = S::Handle;
5170 }
5171 pub struct SetHandle<S: State = Empty>(PhantomData<fn() -> S>);
5173 impl<S: State> sealed::Sealed for SetHandle<S> {}
5174 impl<S: State> State for SetHandle<S> {
5175 type Did = S::Did;
5176 type Handle = Set<members::handle>;
5177 }
5178 #[allow(non_camel_case_types)]
5180 pub mod members {
5181 pub struct did(());
5183 pub struct handle(());
5185 }
5186}
5187
5188pub struct ProfileViewBasicBuilder<'a, S: profile_view_basic_state::State> {
5190 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
5191 __unsafe_private_named: (
5192 ::core::option::Option<crate::app_bsky::actor::ProfileAssociated<'a>>,
5193 ::core::option::Option<jacquard_common::types::string::Uri<'a>>,
5194 ::core::option::Option<jacquard_common::types::string::Datetime>,
5195 ::core::option::Option<jacquard_common::types::value::Data<'a>>,
5196 ::core::option::Option<jacquard_common::types::string::Did<'a>>,
5197 ::core::option::Option<jacquard_common::CowStr<'a>>,
5198 ::core::option::Option<jacquard_common::types::string::Handle<'a>>,
5199 ::core::option::Option<Vec<crate::com_atproto::label::Label<'a>>>,
5200 ::core::option::Option<jacquard_common::CowStr<'a>>,
5201 ::core::option::Option<crate::app_bsky::actor::StatusView<'a>>,
5202 ::core::option::Option<crate::app_bsky::actor::VerificationState<'a>>,
5203 ::core::option::Option<crate::app_bsky::actor::ViewerState<'a>>,
5204 ),
5205 _phantom: ::core::marker::PhantomData<&'a ()>,
5206}
5207
5208impl<'a> ProfileViewBasic<'a> {
5209 pub fn new() -> ProfileViewBasicBuilder<'a, profile_view_basic_state::Empty> {
5211 ProfileViewBasicBuilder::new()
5212 }
5213}
5214
5215impl<'a> ProfileViewBasicBuilder<'a, profile_view_basic_state::Empty> {
5216 pub fn new() -> Self {
5218 ProfileViewBasicBuilder {
5219 _phantom_state: ::core::marker::PhantomData,
5220 __unsafe_private_named: (
5221 None,
5222 None,
5223 None,
5224 None,
5225 None,
5226 None,
5227 None,
5228 None,
5229 None,
5230 None,
5231 None,
5232 None,
5233 ),
5234 _phantom: ::core::marker::PhantomData,
5235 }
5236 }
5237}
5238
5239impl<'a, S: profile_view_basic_state::State> ProfileViewBasicBuilder<'a, S> {
5240 pub fn associated(
5242 mut self,
5243 value: impl Into<Option<crate::app_bsky::actor::ProfileAssociated<'a>>>,
5244 ) -> Self {
5245 self.__unsafe_private_named.0 = value.into();
5246 self
5247 }
5248 pub fn maybe_associated(
5250 mut self,
5251 value: Option<crate::app_bsky::actor::ProfileAssociated<'a>>,
5252 ) -> Self {
5253 self.__unsafe_private_named.0 = value;
5254 self
5255 }
5256}
5257
5258impl<'a, S: profile_view_basic_state::State> ProfileViewBasicBuilder<'a, S> {
5259 pub fn avatar(
5261 mut self,
5262 value: impl Into<Option<jacquard_common::types::string::Uri<'a>>>,
5263 ) -> Self {
5264 self.__unsafe_private_named.1 = value.into();
5265 self
5266 }
5267 pub fn maybe_avatar(
5269 mut self,
5270 value: Option<jacquard_common::types::string::Uri<'a>>,
5271 ) -> Self {
5272 self.__unsafe_private_named.1 = value;
5273 self
5274 }
5275}
5276
5277impl<'a, S: profile_view_basic_state::State> ProfileViewBasicBuilder<'a, S> {
5278 pub fn created_at(
5280 mut self,
5281 value: impl Into<Option<jacquard_common::types::string::Datetime>>,
5282 ) -> Self {
5283 self.__unsafe_private_named.2 = value.into();
5284 self
5285 }
5286 pub fn maybe_created_at(
5288 mut self,
5289 value: Option<jacquard_common::types::string::Datetime>,
5290 ) -> Self {
5291 self.__unsafe_private_named.2 = value;
5292 self
5293 }
5294}
5295
5296impl<'a, S: profile_view_basic_state::State> ProfileViewBasicBuilder<'a, S> {
5297 pub fn debug(
5299 mut self,
5300 value: impl Into<Option<jacquard_common::types::value::Data<'a>>>,
5301 ) -> Self {
5302 self.__unsafe_private_named.3 = value.into();
5303 self
5304 }
5305 pub fn maybe_debug(
5307 mut self,
5308 value: Option<jacquard_common::types::value::Data<'a>>,
5309 ) -> Self {
5310 self.__unsafe_private_named.3 = value;
5311 self
5312 }
5313}
5314
5315impl<'a, S> ProfileViewBasicBuilder<'a, S>
5316where
5317 S: profile_view_basic_state::State,
5318 S::Did: profile_view_basic_state::IsUnset,
5319{
5320 pub fn did(
5322 mut self,
5323 value: impl Into<jacquard_common::types::string::Did<'a>>,
5324 ) -> ProfileViewBasicBuilder<'a, profile_view_basic_state::SetDid<S>> {
5325 self.__unsafe_private_named.4 = ::core::option::Option::Some(value.into());
5326 ProfileViewBasicBuilder {
5327 _phantom_state: ::core::marker::PhantomData,
5328 __unsafe_private_named: self.__unsafe_private_named,
5329 _phantom: ::core::marker::PhantomData,
5330 }
5331 }
5332}
5333
5334impl<'a, S: profile_view_basic_state::State> ProfileViewBasicBuilder<'a, S> {
5335 pub fn display_name(
5337 mut self,
5338 value: impl Into<Option<jacquard_common::CowStr<'a>>>,
5339 ) -> Self {
5340 self.__unsafe_private_named.5 = value.into();
5341 self
5342 }
5343 pub fn maybe_display_name(
5345 mut self,
5346 value: Option<jacquard_common::CowStr<'a>>,
5347 ) -> Self {
5348 self.__unsafe_private_named.5 = value;
5349 self
5350 }
5351}
5352
5353impl<'a, S> ProfileViewBasicBuilder<'a, S>
5354where
5355 S: profile_view_basic_state::State,
5356 S::Handle: profile_view_basic_state::IsUnset,
5357{
5358 pub fn handle(
5360 mut self,
5361 value: impl Into<jacquard_common::types::string::Handle<'a>>,
5362 ) -> ProfileViewBasicBuilder<'a, profile_view_basic_state::SetHandle<S>> {
5363 self.__unsafe_private_named.6 = ::core::option::Option::Some(value.into());
5364 ProfileViewBasicBuilder {
5365 _phantom_state: ::core::marker::PhantomData,
5366 __unsafe_private_named: self.__unsafe_private_named,
5367 _phantom: ::core::marker::PhantomData,
5368 }
5369 }
5370}
5371
5372impl<'a, S: profile_view_basic_state::State> ProfileViewBasicBuilder<'a, S> {
5373 pub fn labels(
5375 mut self,
5376 value: impl Into<Option<Vec<crate::com_atproto::label::Label<'a>>>>,
5377 ) -> Self {
5378 self.__unsafe_private_named.7 = value.into();
5379 self
5380 }
5381 pub fn maybe_labels(
5383 mut self,
5384 value: Option<Vec<crate::com_atproto::label::Label<'a>>>,
5385 ) -> Self {
5386 self.__unsafe_private_named.7 = value;
5387 self
5388 }
5389}
5390
5391impl<'a, S: profile_view_basic_state::State> ProfileViewBasicBuilder<'a, S> {
5392 pub fn pronouns(
5394 mut self,
5395 value: impl Into<Option<jacquard_common::CowStr<'a>>>,
5396 ) -> Self {
5397 self.__unsafe_private_named.8 = value.into();
5398 self
5399 }
5400 pub fn maybe_pronouns(mut self, value: Option<jacquard_common::CowStr<'a>>) -> Self {
5402 self.__unsafe_private_named.8 = value;
5403 self
5404 }
5405}
5406
5407impl<'a, S: profile_view_basic_state::State> ProfileViewBasicBuilder<'a, S> {
5408 pub fn status(
5410 mut self,
5411 value: impl Into<Option<crate::app_bsky::actor::StatusView<'a>>>,
5412 ) -> Self {
5413 self.__unsafe_private_named.9 = value.into();
5414 self
5415 }
5416 pub fn maybe_status(
5418 mut self,
5419 value: Option<crate::app_bsky::actor::StatusView<'a>>,
5420 ) -> Self {
5421 self.__unsafe_private_named.9 = value;
5422 self
5423 }
5424}
5425
5426impl<'a, S: profile_view_basic_state::State> ProfileViewBasicBuilder<'a, S> {
5427 pub fn verification(
5429 mut self,
5430 value: impl Into<Option<crate::app_bsky::actor::VerificationState<'a>>>,
5431 ) -> Self {
5432 self.__unsafe_private_named.10 = value.into();
5433 self
5434 }
5435 pub fn maybe_verification(
5437 mut self,
5438 value: Option<crate::app_bsky::actor::VerificationState<'a>>,
5439 ) -> Self {
5440 self.__unsafe_private_named.10 = value;
5441 self
5442 }
5443}
5444
5445impl<'a, S: profile_view_basic_state::State> ProfileViewBasicBuilder<'a, S> {
5446 pub fn viewer(
5448 mut self,
5449 value: impl Into<Option<crate::app_bsky::actor::ViewerState<'a>>>,
5450 ) -> Self {
5451 self.__unsafe_private_named.11 = value.into();
5452 self
5453 }
5454 pub fn maybe_viewer(
5456 mut self,
5457 value: Option<crate::app_bsky::actor::ViewerState<'a>>,
5458 ) -> Self {
5459 self.__unsafe_private_named.11 = value;
5460 self
5461 }
5462}
5463
5464impl<'a, S> ProfileViewBasicBuilder<'a, S>
5465where
5466 S: profile_view_basic_state::State,
5467 S::Did: profile_view_basic_state::IsSet,
5468 S::Handle: profile_view_basic_state::IsSet,
5469{
5470 pub fn build(self) -> ProfileViewBasic<'a> {
5472 ProfileViewBasic {
5473 associated: self.__unsafe_private_named.0,
5474 avatar: self.__unsafe_private_named.1,
5475 created_at: self.__unsafe_private_named.2,
5476 debug: self.__unsafe_private_named.3,
5477 did: self.__unsafe_private_named.4.unwrap(),
5478 display_name: self.__unsafe_private_named.5,
5479 handle: self.__unsafe_private_named.6.unwrap(),
5480 labels: self.__unsafe_private_named.7,
5481 pronouns: self.__unsafe_private_named.8,
5482 status: self.__unsafe_private_named.9,
5483 verification: self.__unsafe_private_named.10,
5484 viewer: self.__unsafe_private_named.11,
5485 extra_data: Default::default(),
5486 }
5487 }
5488 pub fn build_with_data(
5490 self,
5491 extra_data: std::collections::BTreeMap<
5492 jacquard_common::smol_str::SmolStr,
5493 jacquard_common::types::value::Data<'a>,
5494 >,
5495 ) -> ProfileViewBasic<'a> {
5496 ProfileViewBasic {
5497 associated: self.__unsafe_private_named.0,
5498 avatar: self.__unsafe_private_named.1,
5499 created_at: self.__unsafe_private_named.2,
5500 debug: self.__unsafe_private_named.3,
5501 did: self.__unsafe_private_named.4.unwrap(),
5502 display_name: self.__unsafe_private_named.5,
5503 handle: self.__unsafe_private_named.6.unwrap(),
5504 labels: self.__unsafe_private_named.7,
5505 pronouns: self.__unsafe_private_named.8,
5506 status: self.__unsafe_private_named.9,
5507 verification: self.__unsafe_private_named.10,
5508 viewer: self.__unsafe_private_named.11,
5509 extra_data: Some(extra_data),
5510 }
5511 }
5512}
5513
5514impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ProfileViewBasic<'a> {
5515 fn nsid() -> &'static str {
5516 "app.bsky.actor.defs"
5517 }
5518 fn def_name() -> &'static str {
5519 "profileViewBasic"
5520 }
5521 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
5522 lexicon_doc_app_bsky_actor_defs()
5523 }
5524 fn validate(
5525 &self,
5526 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
5527 if let Some(ref value) = self.display_name {
5528 #[allow(unused_comparisons)]
5529 if <str>::len(value.as_ref()) > 640usize {
5530 return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
5531 path: ::jacquard_lexicon::validation::ValidationPath::from_field(
5532 "display_name",
5533 ),
5534 max: 640usize,
5535 actual: <str>::len(value.as_ref()),
5536 });
5537 }
5538 }
5539 if let Some(ref value) = self.display_name {
5540 {
5541 let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
5542 value.as_ref(),
5543 true,
5544 )
5545 .count();
5546 if count > 64usize {
5547 return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes {
5548 path: ::jacquard_lexicon::validation::ValidationPath::from_field(
5549 "display_name",
5550 ),
5551 max: 64usize,
5552 actual: count,
5553 });
5554 }
5555 }
5556 }
5557 Ok(())
5558 }
5559}
5560
5561#[jacquard_derive::lexicon]
5562#[derive(
5563 serde::Serialize,
5564 serde::Deserialize,
5565 Debug,
5566 Clone,
5567 PartialEq,
5568 Eq,
5569 jacquard_derive::IntoStatic
5570)]
5571#[serde(rename_all = "camelCase")]
5572pub struct ProfileViewDetailed<'a> {
5573 #[serde(skip_serializing_if = "std::option::Option::is_none")]
5574 #[serde(borrow)]
5575 pub associated: Option<crate::app_bsky::actor::ProfileAssociated<'a>>,
5576 #[serde(skip_serializing_if = "std::option::Option::is_none")]
5577 #[serde(borrow)]
5578 pub avatar: Option<jacquard_common::types::string::Uri<'a>>,
5579 #[serde(skip_serializing_if = "std::option::Option::is_none")]
5580 #[serde(borrow)]
5581 pub banner: Option<jacquard_common::types::string::Uri<'a>>,
5582 #[serde(skip_serializing_if = "std::option::Option::is_none")]
5583 pub created_at: Option<jacquard_common::types::string::Datetime>,
5584 #[serde(skip_serializing_if = "std::option::Option::is_none")]
5586 #[serde(borrow)]
5587 pub debug: Option<jacquard_common::types::value::Data<'a>>,
5588 #[serde(skip_serializing_if = "std::option::Option::is_none")]
5589 #[serde(borrow)]
5590 pub description: Option<jacquard_common::CowStr<'a>>,
5591 #[serde(borrow)]
5592 pub did: jacquard_common::types::string::Did<'a>,
5593 #[serde(skip_serializing_if = "std::option::Option::is_none")]
5594 #[serde(borrow)]
5595 pub display_name: Option<jacquard_common::CowStr<'a>>,
5596 #[serde(skip_serializing_if = "std::option::Option::is_none")]
5597 pub followers_count: Option<i64>,
5598 #[serde(skip_serializing_if = "std::option::Option::is_none")]
5599 pub follows_count: Option<i64>,
5600 #[serde(borrow)]
5601 pub handle: jacquard_common::types::string::Handle<'a>,
5602 #[serde(skip_serializing_if = "std::option::Option::is_none")]
5603 pub indexed_at: Option<jacquard_common::types::string::Datetime>,
5604 #[serde(skip_serializing_if = "std::option::Option::is_none")]
5605 #[serde(borrow)]
5606 pub joined_via_starter_pack: Option<
5607 crate::app_bsky::graph::StarterPackViewBasic<'a>,
5608 >,
5609 #[serde(skip_serializing_if = "std::option::Option::is_none")]
5610 #[serde(borrow)]
5611 pub labels: Option<Vec<crate::com_atproto::label::Label<'a>>>,
5612 #[serde(skip_serializing_if = "std::option::Option::is_none")]
5613 #[serde(borrow)]
5614 pub pinned_post: Option<crate::com_atproto::repo::strong_ref::StrongRef<'a>>,
5615 #[serde(skip_serializing_if = "std::option::Option::is_none")]
5616 pub posts_count: Option<i64>,
5617 #[serde(skip_serializing_if = "std::option::Option::is_none")]
5618 #[serde(borrow)]
5619 pub pronouns: Option<jacquard_common::CowStr<'a>>,
5620 #[serde(skip_serializing_if = "std::option::Option::is_none")]
5621 #[serde(borrow)]
5622 pub status: Option<crate::app_bsky::actor::StatusView<'a>>,
5623 #[serde(skip_serializing_if = "std::option::Option::is_none")]
5624 #[serde(borrow)]
5625 pub verification: Option<crate::app_bsky::actor::VerificationState<'a>>,
5626 #[serde(skip_serializing_if = "std::option::Option::is_none")]
5627 #[serde(borrow)]
5628 pub viewer: Option<crate::app_bsky::actor::ViewerState<'a>>,
5629 #[serde(skip_serializing_if = "std::option::Option::is_none")]
5630 #[serde(borrow)]
5631 pub website: Option<jacquard_common::types::string::Uri<'a>>,
5632}
5633
5634pub mod profile_view_detailed_state {
5635
5636 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
5637 #[allow(unused)]
5638 use ::core::marker::PhantomData;
5639 mod sealed {
5640 pub trait Sealed {}
5641 }
5642 pub trait State: sealed::Sealed {
5644 type Did;
5645 type Handle;
5646 }
5647 pub struct Empty(());
5649 impl sealed::Sealed for Empty {}
5650 impl State for Empty {
5651 type Did = Unset;
5652 type Handle = Unset;
5653 }
5654 pub struct SetDid<S: State = Empty>(PhantomData<fn() -> S>);
5656 impl<S: State> sealed::Sealed for SetDid<S> {}
5657 impl<S: State> State for SetDid<S> {
5658 type Did = Set<members::did>;
5659 type Handle = S::Handle;
5660 }
5661 pub struct SetHandle<S: State = Empty>(PhantomData<fn() -> S>);
5663 impl<S: State> sealed::Sealed for SetHandle<S> {}
5664 impl<S: State> State for SetHandle<S> {
5665 type Did = S::Did;
5666 type Handle = Set<members::handle>;
5667 }
5668 #[allow(non_camel_case_types)]
5670 pub mod members {
5671 pub struct did(());
5673 pub struct handle(());
5675 }
5676}
5677
5678pub struct ProfileViewDetailedBuilder<'a, S: profile_view_detailed_state::State> {
5680 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
5681 __unsafe_private_named: (
5682 ::core::option::Option<crate::app_bsky::actor::ProfileAssociated<'a>>,
5683 ::core::option::Option<jacquard_common::types::string::Uri<'a>>,
5684 ::core::option::Option<jacquard_common::types::string::Uri<'a>>,
5685 ::core::option::Option<jacquard_common::types::string::Datetime>,
5686 ::core::option::Option<jacquard_common::types::value::Data<'a>>,
5687 ::core::option::Option<jacquard_common::CowStr<'a>>,
5688 ::core::option::Option<jacquard_common::types::string::Did<'a>>,
5689 ::core::option::Option<jacquard_common::CowStr<'a>>,
5690 ::core::option::Option<i64>,
5691 ::core::option::Option<i64>,
5692 ::core::option::Option<jacquard_common::types::string::Handle<'a>>,
5693 ::core::option::Option<jacquard_common::types::string::Datetime>,
5694 ::core::option::Option<crate::app_bsky::graph::StarterPackViewBasic<'a>>,
5695 ::core::option::Option<Vec<crate::com_atproto::label::Label<'a>>>,
5696 ::core::option::Option<crate::com_atproto::repo::strong_ref::StrongRef<'a>>,
5697 ::core::option::Option<i64>,
5698 ::core::option::Option<jacquard_common::CowStr<'a>>,
5699 ::core::option::Option<crate::app_bsky::actor::StatusView<'a>>,
5700 ::core::option::Option<crate::app_bsky::actor::VerificationState<'a>>,
5701 ::core::option::Option<crate::app_bsky::actor::ViewerState<'a>>,
5702 ::core::option::Option<jacquard_common::types::string::Uri<'a>>,
5703 ),
5704 _phantom: ::core::marker::PhantomData<&'a ()>,
5705}
5706
5707impl<'a> ProfileViewDetailed<'a> {
5708 pub fn new() -> ProfileViewDetailedBuilder<'a, profile_view_detailed_state::Empty> {
5710 ProfileViewDetailedBuilder::new()
5711 }
5712}
5713
5714impl<'a> ProfileViewDetailedBuilder<'a, profile_view_detailed_state::Empty> {
5715 pub fn new() -> Self {
5717 ProfileViewDetailedBuilder {
5718 _phantom_state: ::core::marker::PhantomData,
5719 __unsafe_private_named: (
5720 None,
5721 None,
5722 None,
5723 None,
5724 None,
5725 None,
5726 None,
5727 None,
5728 None,
5729 None,
5730 None,
5731 None,
5732 None,
5733 None,
5734 None,
5735 None,
5736 None,
5737 None,
5738 None,
5739 None,
5740 None,
5741 ),
5742 _phantom: ::core::marker::PhantomData,
5743 }
5744 }
5745}
5746
5747impl<'a, S: profile_view_detailed_state::State> ProfileViewDetailedBuilder<'a, S> {
5748 pub fn associated(
5750 mut self,
5751 value: impl Into<Option<crate::app_bsky::actor::ProfileAssociated<'a>>>,
5752 ) -> Self {
5753 self.__unsafe_private_named.0 = value.into();
5754 self
5755 }
5756 pub fn maybe_associated(
5758 mut self,
5759 value: Option<crate::app_bsky::actor::ProfileAssociated<'a>>,
5760 ) -> Self {
5761 self.__unsafe_private_named.0 = value;
5762 self
5763 }
5764}
5765
5766impl<'a, S: profile_view_detailed_state::State> ProfileViewDetailedBuilder<'a, S> {
5767 pub fn avatar(
5769 mut self,
5770 value: impl Into<Option<jacquard_common::types::string::Uri<'a>>>,
5771 ) -> Self {
5772 self.__unsafe_private_named.1 = value.into();
5773 self
5774 }
5775 pub fn maybe_avatar(
5777 mut self,
5778 value: Option<jacquard_common::types::string::Uri<'a>>,
5779 ) -> Self {
5780 self.__unsafe_private_named.1 = value;
5781 self
5782 }
5783}
5784
5785impl<'a, S: profile_view_detailed_state::State> ProfileViewDetailedBuilder<'a, S> {
5786 pub fn banner(
5788 mut self,
5789 value: impl Into<Option<jacquard_common::types::string::Uri<'a>>>,
5790 ) -> Self {
5791 self.__unsafe_private_named.2 = value.into();
5792 self
5793 }
5794 pub fn maybe_banner(
5796 mut self,
5797 value: Option<jacquard_common::types::string::Uri<'a>>,
5798 ) -> Self {
5799 self.__unsafe_private_named.2 = value;
5800 self
5801 }
5802}
5803
5804impl<'a, S: profile_view_detailed_state::State> ProfileViewDetailedBuilder<'a, S> {
5805 pub fn created_at(
5807 mut self,
5808 value: impl Into<Option<jacquard_common::types::string::Datetime>>,
5809 ) -> Self {
5810 self.__unsafe_private_named.3 = value.into();
5811 self
5812 }
5813 pub fn maybe_created_at(
5815 mut self,
5816 value: Option<jacquard_common::types::string::Datetime>,
5817 ) -> Self {
5818 self.__unsafe_private_named.3 = value;
5819 self
5820 }
5821}
5822
5823impl<'a, S: profile_view_detailed_state::State> ProfileViewDetailedBuilder<'a, S> {
5824 pub fn debug(
5826 mut self,
5827 value: impl Into<Option<jacquard_common::types::value::Data<'a>>>,
5828 ) -> Self {
5829 self.__unsafe_private_named.4 = value.into();
5830 self
5831 }
5832 pub fn maybe_debug(
5834 mut self,
5835 value: Option<jacquard_common::types::value::Data<'a>>,
5836 ) -> Self {
5837 self.__unsafe_private_named.4 = value;
5838 self
5839 }
5840}
5841
5842impl<'a, S: profile_view_detailed_state::State> ProfileViewDetailedBuilder<'a, S> {
5843 pub fn description(
5845 mut self,
5846 value: impl Into<Option<jacquard_common::CowStr<'a>>>,
5847 ) -> Self {
5848 self.__unsafe_private_named.5 = value.into();
5849 self
5850 }
5851 pub fn maybe_description(
5853 mut self,
5854 value: Option<jacquard_common::CowStr<'a>>,
5855 ) -> Self {
5856 self.__unsafe_private_named.5 = value;
5857 self
5858 }
5859}
5860
5861impl<'a, S> ProfileViewDetailedBuilder<'a, S>
5862where
5863 S: profile_view_detailed_state::State,
5864 S::Did: profile_view_detailed_state::IsUnset,
5865{
5866 pub fn did(
5868 mut self,
5869 value: impl Into<jacquard_common::types::string::Did<'a>>,
5870 ) -> ProfileViewDetailedBuilder<'a, profile_view_detailed_state::SetDid<S>> {
5871 self.__unsafe_private_named.6 = ::core::option::Option::Some(value.into());
5872 ProfileViewDetailedBuilder {
5873 _phantom_state: ::core::marker::PhantomData,
5874 __unsafe_private_named: self.__unsafe_private_named,
5875 _phantom: ::core::marker::PhantomData,
5876 }
5877 }
5878}
5879
5880impl<'a, S: profile_view_detailed_state::State> ProfileViewDetailedBuilder<'a, S> {
5881 pub fn display_name(
5883 mut self,
5884 value: impl Into<Option<jacquard_common::CowStr<'a>>>,
5885 ) -> Self {
5886 self.__unsafe_private_named.7 = value.into();
5887 self
5888 }
5889 pub fn maybe_display_name(
5891 mut self,
5892 value: Option<jacquard_common::CowStr<'a>>,
5893 ) -> Self {
5894 self.__unsafe_private_named.7 = value;
5895 self
5896 }
5897}
5898
5899impl<'a, S: profile_view_detailed_state::State> ProfileViewDetailedBuilder<'a, S> {
5900 pub fn followers_count(mut self, value: impl Into<Option<i64>>) -> Self {
5902 self.__unsafe_private_named.8 = value.into();
5903 self
5904 }
5905 pub fn maybe_followers_count(mut self, value: Option<i64>) -> Self {
5907 self.__unsafe_private_named.8 = value;
5908 self
5909 }
5910}
5911
5912impl<'a, S: profile_view_detailed_state::State> ProfileViewDetailedBuilder<'a, S> {
5913 pub fn follows_count(mut self, value: impl Into<Option<i64>>) -> Self {
5915 self.__unsafe_private_named.9 = value.into();
5916 self
5917 }
5918 pub fn maybe_follows_count(mut self, value: Option<i64>) -> Self {
5920 self.__unsafe_private_named.9 = value;
5921 self
5922 }
5923}
5924
5925impl<'a, S> ProfileViewDetailedBuilder<'a, S>
5926where
5927 S: profile_view_detailed_state::State,
5928 S::Handle: profile_view_detailed_state::IsUnset,
5929{
5930 pub fn handle(
5932 mut self,
5933 value: impl Into<jacquard_common::types::string::Handle<'a>>,
5934 ) -> ProfileViewDetailedBuilder<'a, profile_view_detailed_state::SetHandle<S>> {
5935 self.__unsafe_private_named.10 = ::core::option::Option::Some(value.into());
5936 ProfileViewDetailedBuilder {
5937 _phantom_state: ::core::marker::PhantomData,
5938 __unsafe_private_named: self.__unsafe_private_named,
5939 _phantom: ::core::marker::PhantomData,
5940 }
5941 }
5942}
5943
5944impl<'a, S: profile_view_detailed_state::State> ProfileViewDetailedBuilder<'a, S> {
5945 pub fn indexed_at(
5947 mut self,
5948 value: impl Into<Option<jacquard_common::types::string::Datetime>>,
5949 ) -> Self {
5950 self.__unsafe_private_named.11 = value.into();
5951 self
5952 }
5953 pub fn maybe_indexed_at(
5955 mut self,
5956 value: Option<jacquard_common::types::string::Datetime>,
5957 ) -> Self {
5958 self.__unsafe_private_named.11 = value;
5959 self
5960 }
5961}
5962
5963impl<'a, S: profile_view_detailed_state::State> ProfileViewDetailedBuilder<'a, S> {
5964 pub fn joined_via_starter_pack(
5966 mut self,
5967 value: impl Into<Option<crate::app_bsky::graph::StarterPackViewBasic<'a>>>,
5968 ) -> Self {
5969 self.__unsafe_private_named.12 = value.into();
5970 self
5971 }
5972 pub fn maybe_joined_via_starter_pack(
5974 mut self,
5975 value: Option<crate::app_bsky::graph::StarterPackViewBasic<'a>>,
5976 ) -> Self {
5977 self.__unsafe_private_named.12 = value;
5978 self
5979 }
5980}
5981
5982impl<'a, S: profile_view_detailed_state::State> ProfileViewDetailedBuilder<'a, S> {
5983 pub fn labels(
5985 mut self,
5986 value: impl Into<Option<Vec<crate::com_atproto::label::Label<'a>>>>,
5987 ) -> Self {
5988 self.__unsafe_private_named.13 = value.into();
5989 self
5990 }
5991 pub fn maybe_labels(
5993 mut self,
5994 value: Option<Vec<crate::com_atproto::label::Label<'a>>>,
5995 ) -> Self {
5996 self.__unsafe_private_named.13 = value;
5997 self
5998 }
5999}
6000
6001impl<'a, S: profile_view_detailed_state::State> ProfileViewDetailedBuilder<'a, S> {
6002 pub fn pinned_post(
6004 mut self,
6005 value: impl Into<Option<crate::com_atproto::repo::strong_ref::StrongRef<'a>>>,
6006 ) -> Self {
6007 self.__unsafe_private_named.14 = value.into();
6008 self
6009 }
6010 pub fn maybe_pinned_post(
6012 mut self,
6013 value: Option<crate::com_atproto::repo::strong_ref::StrongRef<'a>>,
6014 ) -> Self {
6015 self.__unsafe_private_named.14 = value;
6016 self
6017 }
6018}
6019
6020impl<'a, S: profile_view_detailed_state::State> ProfileViewDetailedBuilder<'a, S> {
6021 pub fn posts_count(mut self, value: impl Into<Option<i64>>) -> Self {
6023 self.__unsafe_private_named.15 = value.into();
6024 self
6025 }
6026 pub fn maybe_posts_count(mut self, value: Option<i64>) -> Self {
6028 self.__unsafe_private_named.15 = value;
6029 self
6030 }
6031}
6032
6033impl<'a, S: profile_view_detailed_state::State> ProfileViewDetailedBuilder<'a, S> {
6034 pub fn pronouns(
6036 mut self,
6037 value: impl Into<Option<jacquard_common::CowStr<'a>>>,
6038 ) -> Self {
6039 self.__unsafe_private_named.16 = value.into();
6040 self
6041 }
6042 pub fn maybe_pronouns(mut self, value: Option<jacquard_common::CowStr<'a>>) -> Self {
6044 self.__unsafe_private_named.16 = value;
6045 self
6046 }
6047}
6048
6049impl<'a, S: profile_view_detailed_state::State> ProfileViewDetailedBuilder<'a, S> {
6050 pub fn status(
6052 mut self,
6053 value: impl Into<Option<crate::app_bsky::actor::StatusView<'a>>>,
6054 ) -> Self {
6055 self.__unsafe_private_named.17 = value.into();
6056 self
6057 }
6058 pub fn maybe_status(
6060 mut self,
6061 value: Option<crate::app_bsky::actor::StatusView<'a>>,
6062 ) -> Self {
6063 self.__unsafe_private_named.17 = value;
6064 self
6065 }
6066}
6067
6068impl<'a, S: profile_view_detailed_state::State> ProfileViewDetailedBuilder<'a, S> {
6069 pub fn verification(
6071 mut self,
6072 value: impl Into<Option<crate::app_bsky::actor::VerificationState<'a>>>,
6073 ) -> Self {
6074 self.__unsafe_private_named.18 = value.into();
6075 self
6076 }
6077 pub fn maybe_verification(
6079 mut self,
6080 value: Option<crate::app_bsky::actor::VerificationState<'a>>,
6081 ) -> Self {
6082 self.__unsafe_private_named.18 = value;
6083 self
6084 }
6085}
6086
6087impl<'a, S: profile_view_detailed_state::State> ProfileViewDetailedBuilder<'a, S> {
6088 pub fn viewer(
6090 mut self,
6091 value: impl Into<Option<crate::app_bsky::actor::ViewerState<'a>>>,
6092 ) -> Self {
6093 self.__unsafe_private_named.19 = value.into();
6094 self
6095 }
6096 pub fn maybe_viewer(
6098 mut self,
6099 value: Option<crate::app_bsky::actor::ViewerState<'a>>,
6100 ) -> Self {
6101 self.__unsafe_private_named.19 = value;
6102 self
6103 }
6104}
6105
6106impl<'a, S: profile_view_detailed_state::State> ProfileViewDetailedBuilder<'a, S> {
6107 pub fn website(
6109 mut self,
6110 value: impl Into<Option<jacquard_common::types::string::Uri<'a>>>,
6111 ) -> Self {
6112 self.__unsafe_private_named.20 = value.into();
6113 self
6114 }
6115 pub fn maybe_website(
6117 mut self,
6118 value: Option<jacquard_common::types::string::Uri<'a>>,
6119 ) -> Self {
6120 self.__unsafe_private_named.20 = value;
6121 self
6122 }
6123}
6124
6125impl<'a, S> ProfileViewDetailedBuilder<'a, S>
6126where
6127 S: profile_view_detailed_state::State,
6128 S::Did: profile_view_detailed_state::IsSet,
6129 S::Handle: profile_view_detailed_state::IsSet,
6130{
6131 pub fn build(self) -> ProfileViewDetailed<'a> {
6133 ProfileViewDetailed {
6134 associated: self.__unsafe_private_named.0,
6135 avatar: self.__unsafe_private_named.1,
6136 banner: self.__unsafe_private_named.2,
6137 created_at: self.__unsafe_private_named.3,
6138 debug: self.__unsafe_private_named.4,
6139 description: self.__unsafe_private_named.5,
6140 did: self.__unsafe_private_named.6.unwrap(),
6141 display_name: self.__unsafe_private_named.7,
6142 followers_count: self.__unsafe_private_named.8,
6143 follows_count: self.__unsafe_private_named.9,
6144 handle: self.__unsafe_private_named.10.unwrap(),
6145 indexed_at: self.__unsafe_private_named.11,
6146 joined_via_starter_pack: self.__unsafe_private_named.12,
6147 labels: self.__unsafe_private_named.13,
6148 pinned_post: self.__unsafe_private_named.14,
6149 posts_count: self.__unsafe_private_named.15,
6150 pronouns: self.__unsafe_private_named.16,
6151 status: self.__unsafe_private_named.17,
6152 verification: self.__unsafe_private_named.18,
6153 viewer: self.__unsafe_private_named.19,
6154 website: self.__unsafe_private_named.20,
6155 extra_data: Default::default(),
6156 }
6157 }
6158 pub fn build_with_data(
6160 self,
6161 extra_data: std::collections::BTreeMap<
6162 jacquard_common::smol_str::SmolStr,
6163 jacquard_common::types::value::Data<'a>,
6164 >,
6165 ) -> ProfileViewDetailed<'a> {
6166 ProfileViewDetailed {
6167 associated: self.__unsafe_private_named.0,
6168 avatar: self.__unsafe_private_named.1,
6169 banner: self.__unsafe_private_named.2,
6170 created_at: self.__unsafe_private_named.3,
6171 debug: self.__unsafe_private_named.4,
6172 description: self.__unsafe_private_named.5,
6173 did: self.__unsafe_private_named.6.unwrap(),
6174 display_name: self.__unsafe_private_named.7,
6175 followers_count: self.__unsafe_private_named.8,
6176 follows_count: self.__unsafe_private_named.9,
6177 handle: self.__unsafe_private_named.10.unwrap(),
6178 indexed_at: self.__unsafe_private_named.11,
6179 joined_via_starter_pack: self.__unsafe_private_named.12,
6180 labels: self.__unsafe_private_named.13,
6181 pinned_post: self.__unsafe_private_named.14,
6182 posts_count: self.__unsafe_private_named.15,
6183 pronouns: self.__unsafe_private_named.16,
6184 status: self.__unsafe_private_named.17,
6185 verification: self.__unsafe_private_named.18,
6186 viewer: self.__unsafe_private_named.19,
6187 website: self.__unsafe_private_named.20,
6188 extra_data: Some(extra_data),
6189 }
6190 }
6191}
6192
6193impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ProfileViewDetailed<'a> {
6194 fn nsid() -> &'static str {
6195 "app.bsky.actor.defs"
6196 }
6197 fn def_name() -> &'static str {
6198 "profileViewDetailed"
6199 }
6200 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
6201 lexicon_doc_app_bsky_actor_defs()
6202 }
6203 fn validate(
6204 &self,
6205 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
6206 if let Some(ref value) = self.description {
6207 #[allow(unused_comparisons)]
6208 if <str>::len(value.as_ref()) > 2560usize {
6209 return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
6210 path: ::jacquard_lexicon::validation::ValidationPath::from_field(
6211 "description",
6212 ),
6213 max: 2560usize,
6214 actual: <str>::len(value.as_ref()),
6215 });
6216 }
6217 }
6218 if let Some(ref value) = self.description {
6219 {
6220 let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
6221 value.as_ref(),
6222 true,
6223 )
6224 .count();
6225 if count > 256usize {
6226 return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes {
6227 path: ::jacquard_lexicon::validation::ValidationPath::from_field(
6228 "description",
6229 ),
6230 max: 256usize,
6231 actual: count,
6232 });
6233 }
6234 }
6235 }
6236 if let Some(ref value) = self.display_name {
6237 #[allow(unused_comparisons)]
6238 if <str>::len(value.as_ref()) > 640usize {
6239 return Err(::jacquard_lexicon::validation::ConstraintError::MaxLength {
6240 path: ::jacquard_lexicon::validation::ValidationPath::from_field(
6241 "display_name",
6242 ),
6243 max: 640usize,
6244 actual: <str>::len(value.as_ref()),
6245 });
6246 }
6247 }
6248 if let Some(ref value) = self.display_name {
6249 {
6250 let count = ::unicode_segmentation::UnicodeSegmentation::graphemes(
6251 value.as_ref(),
6252 true,
6253 )
6254 .count();
6255 if count > 64usize {
6256 return Err(::jacquard_lexicon::validation::ConstraintError::MaxGraphemes {
6257 path: ::jacquard_lexicon::validation::ValidationPath::from_field(
6258 "display_name",
6259 ),
6260 max: 64usize,
6261 actual: count,
6262 });
6263 }
6264 }
6265 }
6266 Ok(())
6267 }
6268}
6269
6270#[jacquard_derive::lexicon]
6271#[derive(
6272 serde::Serialize,
6273 serde::Deserialize,
6274 Debug,
6275 Clone,
6276 PartialEq,
6277 Eq,
6278 jacquard_derive::IntoStatic
6279)]
6280#[serde(rename_all = "camelCase")]
6281pub struct SavedFeed<'a> {
6282 #[serde(borrow)]
6283 pub id: jacquard_common::CowStr<'a>,
6284 pub pinned: bool,
6285 #[serde(borrow)]
6286 pub r#type: jacquard_common::CowStr<'a>,
6287 #[serde(borrow)]
6288 pub value: jacquard_common::CowStr<'a>,
6289}
6290
6291pub mod saved_feed_state {
6292
6293 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
6294 #[allow(unused)]
6295 use ::core::marker::PhantomData;
6296 mod sealed {
6297 pub trait Sealed {}
6298 }
6299 pub trait State: sealed::Sealed {
6301 type Id;
6302 type Type;
6303 type Value;
6304 type Pinned;
6305 }
6306 pub struct Empty(());
6308 impl sealed::Sealed for Empty {}
6309 impl State for Empty {
6310 type Id = Unset;
6311 type Type = Unset;
6312 type Value = Unset;
6313 type Pinned = Unset;
6314 }
6315 pub struct SetId<S: State = Empty>(PhantomData<fn() -> S>);
6317 impl<S: State> sealed::Sealed for SetId<S> {}
6318 impl<S: State> State for SetId<S> {
6319 type Id = Set<members::id>;
6320 type Type = S::Type;
6321 type Value = S::Value;
6322 type Pinned = S::Pinned;
6323 }
6324 pub struct SetType<S: State = Empty>(PhantomData<fn() -> S>);
6326 impl<S: State> sealed::Sealed for SetType<S> {}
6327 impl<S: State> State for SetType<S> {
6328 type Id = S::Id;
6329 type Type = Set<members::r#type>;
6330 type Value = S::Value;
6331 type Pinned = S::Pinned;
6332 }
6333 pub struct SetValue<S: State = Empty>(PhantomData<fn() -> S>);
6335 impl<S: State> sealed::Sealed for SetValue<S> {}
6336 impl<S: State> State for SetValue<S> {
6337 type Id = S::Id;
6338 type Type = S::Type;
6339 type Value = Set<members::value>;
6340 type Pinned = S::Pinned;
6341 }
6342 pub struct SetPinned<S: State = Empty>(PhantomData<fn() -> S>);
6344 impl<S: State> sealed::Sealed for SetPinned<S> {}
6345 impl<S: State> State for SetPinned<S> {
6346 type Id = S::Id;
6347 type Type = S::Type;
6348 type Value = S::Value;
6349 type Pinned = Set<members::pinned>;
6350 }
6351 #[allow(non_camel_case_types)]
6353 pub mod members {
6354 pub struct id(());
6356 pub struct r#type(());
6358 pub struct value(());
6360 pub struct pinned(());
6362 }
6363}
6364
6365pub struct SavedFeedBuilder<'a, S: saved_feed_state::State> {
6367 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
6368 __unsafe_private_named: (
6369 ::core::option::Option<jacquard_common::CowStr<'a>>,
6370 ::core::option::Option<bool>,
6371 ::core::option::Option<jacquard_common::CowStr<'a>>,
6372 ::core::option::Option<jacquard_common::CowStr<'a>>,
6373 ),
6374 _phantom: ::core::marker::PhantomData<&'a ()>,
6375}
6376
6377impl<'a> SavedFeed<'a> {
6378 pub fn new() -> SavedFeedBuilder<'a, saved_feed_state::Empty> {
6380 SavedFeedBuilder::new()
6381 }
6382}
6383
6384impl<'a> SavedFeedBuilder<'a, saved_feed_state::Empty> {
6385 pub fn new() -> Self {
6387 SavedFeedBuilder {
6388 _phantom_state: ::core::marker::PhantomData,
6389 __unsafe_private_named: (None, None, None, None),
6390 _phantom: ::core::marker::PhantomData,
6391 }
6392 }
6393}
6394
6395impl<'a, S> SavedFeedBuilder<'a, S>
6396where
6397 S: saved_feed_state::State,
6398 S::Id: saved_feed_state::IsUnset,
6399{
6400 pub fn id(
6402 mut self,
6403 value: impl Into<jacquard_common::CowStr<'a>>,
6404 ) -> SavedFeedBuilder<'a, saved_feed_state::SetId<S>> {
6405 self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
6406 SavedFeedBuilder {
6407 _phantom_state: ::core::marker::PhantomData,
6408 __unsafe_private_named: self.__unsafe_private_named,
6409 _phantom: ::core::marker::PhantomData,
6410 }
6411 }
6412}
6413
6414impl<'a, S> SavedFeedBuilder<'a, S>
6415where
6416 S: saved_feed_state::State,
6417 S::Pinned: saved_feed_state::IsUnset,
6418{
6419 pub fn pinned(
6421 mut self,
6422 value: impl Into<bool>,
6423 ) -> SavedFeedBuilder<'a, saved_feed_state::SetPinned<S>> {
6424 self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
6425 SavedFeedBuilder {
6426 _phantom_state: ::core::marker::PhantomData,
6427 __unsafe_private_named: self.__unsafe_private_named,
6428 _phantom: ::core::marker::PhantomData,
6429 }
6430 }
6431}
6432
6433impl<'a, S> SavedFeedBuilder<'a, S>
6434where
6435 S: saved_feed_state::State,
6436 S::Type: saved_feed_state::IsUnset,
6437{
6438 pub fn r#type(
6440 mut self,
6441 value: impl Into<jacquard_common::CowStr<'a>>,
6442 ) -> SavedFeedBuilder<'a, saved_feed_state::SetType<S>> {
6443 self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into());
6444 SavedFeedBuilder {
6445 _phantom_state: ::core::marker::PhantomData,
6446 __unsafe_private_named: self.__unsafe_private_named,
6447 _phantom: ::core::marker::PhantomData,
6448 }
6449 }
6450}
6451
6452impl<'a, S> SavedFeedBuilder<'a, S>
6453where
6454 S: saved_feed_state::State,
6455 S::Value: saved_feed_state::IsUnset,
6456{
6457 pub fn value(
6459 mut self,
6460 value: impl Into<jacquard_common::CowStr<'a>>,
6461 ) -> SavedFeedBuilder<'a, saved_feed_state::SetValue<S>> {
6462 self.__unsafe_private_named.3 = ::core::option::Option::Some(value.into());
6463 SavedFeedBuilder {
6464 _phantom_state: ::core::marker::PhantomData,
6465 __unsafe_private_named: self.__unsafe_private_named,
6466 _phantom: ::core::marker::PhantomData,
6467 }
6468 }
6469}
6470
6471impl<'a, S> SavedFeedBuilder<'a, S>
6472where
6473 S: saved_feed_state::State,
6474 S::Id: saved_feed_state::IsSet,
6475 S::Type: saved_feed_state::IsSet,
6476 S::Value: saved_feed_state::IsSet,
6477 S::Pinned: saved_feed_state::IsSet,
6478{
6479 pub fn build(self) -> SavedFeed<'a> {
6481 SavedFeed {
6482 id: self.__unsafe_private_named.0.unwrap(),
6483 pinned: self.__unsafe_private_named.1.unwrap(),
6484 r#type: self.__unsafe_private_named.2.unwrap(),
6485 value: self.__unsafe_private_named.3.unwrap(),
6486 extra_data: Default::default(),
6487 }
6488 }
6489 pub fn build_with_data(
6491 self,
6492 extra_data: std::collections::BTreeMap<
6493 jacquard_common::smol_str::SmolStr,
6494 jacquard_common::types::value::Data<'a>,
6495 >,
6496 ) -> SavedFeed<'a> {
6497 SavedFeed {
6498 id: self.__unsafe_private_named.0.unwrap(),
6499 pinned: self.__unsafe_private_named.1.unwrap(),
6500 r#type: self.__unsafe_private_named.2.unwrap(),
6501 value: self.__unsafe_private_named.3.unwrap(),
6502 extra_data: Some(extra_data),
6503 }
6504 }
6505}
6506
6507impl<'a> ::jacquard_lexicon::schema::LexiconSchema for SavedFeed<'a> {
6508 fn nsid() -> &'static str {
6509 "app.bsky.actor.defs"
6510 }
6511 fn def_name() -> &'static str {
6512 "savedFeed"
6513 }
6514 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
6515 lexicon_doc_app_bsky_actor_defs()
6516 }
6517 fn validate(
6518 &self,
6519 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
6520 Ok(())
6521 }
6522}
6523
6524#[jacquard_derive::lexicon]
6525#[derive(
6526 serde::Serialize,
6527 serde::Deserialize,
6528 Debug,
6529 Clone,
6530 PartialEq,
6531 Eq,
6532 jacquard_derive::IntoStatic
6533)]
6534#[serde(rename_all = "camelCase")]
6535pub struct SavedFeedsPref<'a> {
6536 #[serde(borrow)]
6537 pub pinned: Vec<jacquard_common::types::string::AtUri<'a>>,
6538 #[serde(borrow)]
6539 pub saved: Vec<jacquard_common::types::string::AtUri<'a>>,
6540 #[serde(skip_serializing_if = "std::option::Option::is_none")]
6541 pub timeline_index: Option<i64>,
6542}
6543
6544pub mod saved_feeds_pref_state {
6545
6546 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
6547 #[allow(unused)]
6548 use ::core::marker::PhantomData;
6549 mod sealed {
6550 pub trait Sealed {}
6551 }
6552 pub trait State: sealed::Sealed {
6554 type Pinned;
6555 type Saved;
6556 }
6557 pub struct Empty(());
6559 impl sealed::Sealed for Empty {}
6560 impl State for Empty {
6561 type Pinned = Unset;
6562 type Saved = Unset;
6563 }
6564 pub struct SetPinned<S: State = Empty>(PhantomData<fn() -> S>);
6566 impl<S: State> sealed::Sealed for SetPinned<S> {}
6567 impl<S: State> State for SetPinned<S> {
6568 type Pinned = Set<members::pinned>;
6569 type Saved = S::Saved;
6570 }
6571 pub struct SetSaved<S: State = Empty>(PhantomData<fn() -> S>);
6573 impl<S: State> sealed::Sealed for SetSaved<S> {}
6574 impl<S: State> State for SetSaved<S> {
6575 type Pinned = S::Pinned;
6576 type Saved = Set<members::saved>;
6577 }
6578 #[allow(non_camel_case_types)]
6580 pub mod members {
6581 pub struct pinned(());
6583 pub struct saved(());
6585 }
6586}
6587
6588pub struct SavedFeedsPrefBuilder<'a, S: saved_feeds_pref_state::State> {
6590 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
6591 __unsafe_private_named: (
6592 ::core::option::Option<Vec<jacquard_common::types::string::AtUri<'a>>>,
6593 ::core::option::Option<Vec<jacquard_common::types::string::AtUri<'a>>>,
6594 ::core::option::Option<i64>,
6595 ),
6596 _phantom: ::core::marker::PhantomData<&'a ()>,
6597}
6598
6599impl<'a> SavedFeedsPref<'a> {
6600 pub fn new() -> SavedFeedsPrefBuilder<'a, saved_feeds_pref_state::Empty> {
6602 SavedFeedsPrefBuilder::new()
6603 }
6604}
6605
6606impl<'a> SavedFeedsPrefBuilder<'a, saved_feeds_pref_state::Empty> {
6607 pub fn new() -> Self {
6609 SavedFeedsPrefBuilder {
6610 _phantom_state: ::core::marker::PhantomData,
6611 __unsafe_private_named: (None, None, None),
6612 _phantom: ::core::marker::PhantomData,
6613 }
6614 }
6615}
6616
6617impl<'a, S> SavedFeedsPrefBuilder<'a, S>
6618where
6619 S: saved_feeds_pref_state::State,
6620 S::Pinned: saved_feeds_pref_state::IsUnset,
6621{
6622 pub fn pinned(
6624 mut self,
6625 value: impl Into<Vec<jacquard_common::types::string::AtUri<'a>>>,
6626 ) -> SavedFeedsPrefBuilder<'a, saved_feeds_pref_state::SetPinned<S>> {
6627 self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
6628 SavedFeedsPrefBuilder {
6629 _phantom_state: ::core::marker::PhantomData,
6630 __unsafe_private_named: self.__unsafe_private_named,
6631 _phantom: ::core::marker::PhantomData,
6632 }
6633 }
6634}
6635
6636impl<'a, S> SavedFeedsPrefBuilder<'a, S>
6637where
6638 S: saved_feeds_pref_state::State,
6639 S::Saved: saved_feeds_pref_state::IsUnset,
6640{
6641 pub fn saved(
6643 mut self,
6644 value: impl Into<Vec<jacquard_common::types::string::AtUri<'a>>>,
6645 ) -> SavedFeedsPrefBuilder<'a, saved_feeds_pref_state::SetSaved<S>> {
6646 self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
6647 SavedFeedsPrefBuilder {
6648 _phantom_state: ::core::marker::PhantomData,
6649 __unsafe_private_named: self.__unsafe_private_named,
6650 _phantom: ::core::marker::PhantomData,
6651 }
6652 }
6653}
6654
6655impl<'a, S: saved_feeds_pref_state::State> SavedFeedsPrefBuilder<'a, S> {
6656 pub fn timeline_index(mut self, value: impl Into<Option<i64>>) -> Self {
6658 self.__unsafe_private_named.2 = value.into();
6659 self
6660 }
6661 pub fn maybe_timeline_index(mut self, value: Option<i64>) -> Self {
6663 self.__unsafe_private_named.2 = value;
6664 self
6665 }
6666}
6667
6668impl<'a, S> SavedFeedsPrefBuilder<'a, S>
6669where
6670 S: saved_feeds_pref_state::State,
6671 S::Pinned: saved_feeds_pref_state::IsSet,
6672 S::Saved: saved_feeds_pref_state::IsSet,
6673{
6674 pub fn build(self) -> SavedFeedsPref<'a> {
6676 SavedFeedsPref {
6677 pinned: self.__unsafe_private_named.0.unwrap(),
6678 saved: self.__unsafe_private_named.1.unwrap(),
6679 timeline_index: self.__unsafe_private_named.2,
6680 extra_data: Default::default(),
6681 }
6682 }
6683 pub fn build_with_data(
6685 self,
6686 extra_data: std::collections::BTreeMap<
6687 jacquard_common::smol_str::SmolStr,
6688 jacquard_common::types::value::Data<'a>,
6689 >,
6690 ) -> SavedFeedsPref<'a> {
6691 SavedFeedsPref {
6692 pinned: self.__unsafe_private_named.0.unwrap(),
6693 saved: self.__unsafe_private_named.1.unwrap(),
6694 timeline_index: self.__unsafe_private_named.2,
6695 extra_data: Some(extra_data),
6696 }
6697 }
6698}
6699
6700impl<'a> ::jacquard_lexicon::schema::LexiconSchema for SavedFeedsPref<'a> {
6701 fn nsid() -> &'static str {
6702 "app.bsky.actor.defs"
6703 }
6704 fn def_name() -> &'static str {
6705 "savedFeedsPref"
6706 }
6707 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
6708 lexicon_doc_app_bsky_actor_defs()
6709 }
6710 fn validate(
6711 &self,
6712 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
6713 Ok(())
6714 }
6715}
6716
6717#[jacquard_derive::lexicon]
6718#[derive(
6719 serde::Serialize,
6720 serde::Deserialize,
6721 Debug,
6722 Clone,
6723 PartialEq,
6724 Eq,
6725 jacquard_derive::IntoStatic
6726)]
6727#[serde(rename_all = "camelCase")]
6728pub struct SavedFeedsPrefV2<'a> {
6729 #[serde(borrow)]
6730 pub items: Vec<crate::app_bsky::actor::SavedFeed<'a>>,
6731}
6732
6733pub mod saved_feeds_pref_v2_state {
6734
6735 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
6736 #[allow(unused)]
6737 use ::core::marker::PhantomData;
6738 mod sealed {
6739 pub trait Sealed {}
6740 }
6741 pub trait State: sealed::Sealed {
6743 type Items;
6744 }
6745 pub struct Empty(());
6747 impl sealed::Sealed for Empty {}
6748 impl State for Empty {
6749 type Items = Unset;
6750 }
6751 pub struct SetItems<S: State = Empty>(PhantomData<fn() -> S>);
6753 impl<S: State> sealed::Sealed for SetItems<S> {}
6754 impl<S: State> State for SetItems<S> {
6755 type Items = Set<members::items>;
6756 }
6757 #[allow(non_camel_case_types)]
6759 pub mod members {
6760 pub struct items(());
6762 }
6763}
6764
6765pub struct SavedFeedsPrefV2Builder<'a, S: saved_feeds_pref_v2_state::State> {
6767 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
6768 __unsafe_private_named: (
6769 ::core::option::Option<Vec<crate::app_bsky::actor::SavedFeed<'a>>>,
6770 ),
6771 _phantom: ::core::marker::PhantomData<&'a ()>,
6772}
6773
6774impl<'a> SavedFeedsPrefV2<'a> {
6775 pub fn new() -> SavedFeedsPrefV2Builder<'a, saved_feeds_pref_v2_state::Empty> {
6777 SavedFeedsPrefV2Builder::new()
6778 }
6779}
6780
6781impl<'a> SavedFeedsPrefV2Builder<'a, saved_feeds_pref_v2_state::Empty> {
6782 pub fn new() -> Self {
6784 SavedFeedsPrefV2Builder {
6785 _phantom_state: ::core::marker::PhantomData,
6786 __unsafe_private_named: (None,),
6787 _phantom: ::core::marker::PhantomData,
6788 }
6789 }
6790}
6791
6792impl<'a, S> SavedFeedsPrefV2Builder<'a, S>
6793where
6794 S: saved_feeds_pref_v2_state::State,
6795 S::Items: saved_feeds_pref_v2_state::IsUnset,
6796{
6797 pub fn items(
6799 mut self,
6800 value: impl Into<Vec<crate::app_bsky::actor::SavedFeed<'a>>>,
6801 ) -> SavedFeedsPrefV2Builder<'a, saved_feeds_pref_v2_state::SetItems<S>> {
6802 self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
6803 SavedFeedsPrefV2Builder {
6804 _phantom_state: ::core::marker::PhantomData,
6805 __unsafe_private_named: self.__unsafe_private_named,
6806 _phantom: ::core::marker::PhantomData,
6807 }
6808 }
6809}
6810
6811impl<'a, S> SavedFeedsPrefV2Builder<'a, S>
6812where
6813 S: saved_feeds_pref_v2_state::State,
6814 S::Items: saved_feeds_pref_v2_state::IsSet,
6815{
6816 pub fn build(self) -> SavedFeedsPrefV2<'a> {
6818 SavedFeedsPrefV2 {
6819 items: self.__unsafe_private_named.0.unwrap(),
6820 extra_data: Default::default(),
6821 }
6822 }
6823 pub fn build_with_data(
6825 self,
6826 extra_data: std::collections::BTreeMap<
6827 jacquard_common::smol_str::SmolStr,
6828 jacquard_common::types::value::Data<'a>,
6829 >,
6830 ) -> SavedFeedsPrefV2<'a> {
6831 SavedFeedsPrefV2 {
6832 items: self.__unsafe_private_named.0.unwrap(),
6833 extra_data: Some(extra_data),
6834 }
6835 }
6836}
6837
6838impl<'a> ::jacquard_lexicon::schema::LexiconSchema for SavedFeedsPrefV2<'a> {
6839 fn nsid() -> &'static str {
6840 "app.bsky.actor.defs"
6841 }
6842 fn def_name() -> &'static str {
6843 "savedFeedsPrefV2"
6844 }
6845 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
6846 lexicon_doc_app_bsky_actor_defs()
6847 }
6848 fn validate(
6849 &self,
6850 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
6851 Ok(())
6852 }
6853}
6854
6855#[jacquard_derive::lexicon]
6856#[derive(
6857 serde::Serialize,
6858 serde::Deserialize,
6859 Debug,
6860 Clone,
6861 PartialEq,
6862 Eq,
6863 jacquard_derive::IntoStatic
6864)]
6865#[serde(rename_all = "camelCase")]
6866pub struct StatusView<'a> {
6867 #[serde(skip_serializing_if = "std::option::Option::is_none")]
6869 #[serde(borrow)]
6870 pub embed: Option<crate::app_bsky::embed::external::View<'a>>,
6871 #[serde(skip_serializing_if = "std::option::Option::is_none")]
6873 pub expires_at: Option<jacquard_common::types::string::Datetime>,
6874 #[serde(skip_serializing_if = "std::option::Option::is_none")]
6876 pub is_active: Option<bool>,
6877 #[serde(borrow)]
6878 pub record: jacquard_common::types::value::Data<'a>,
6879 #[serde(borrow)]
6881 pub status: jacquard_common::CowStr<'a>,
6882}
6883
6884pub mod status_view_state {
6885
6886 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
6887 #[allow(unused)]
6888 use ::core::marker::PhantomData;
6889 mod sealed {
6890 pub trait Sealed {}
6891 }
6892 pub trait State: sealed::Sealed {
6894 type Status;
6895 type Record;
6896 }
6897 pub struct Empty(());
6899 impl sealed::Sealed for Empty {}
6900 impl State for Empty {
6901 type Status = Unset;
6902 type Record = Unset;
6903 }
6904 pub struct SetStatus<S: State = Empty>(PhantomData<fn() -> S>);
6906 impl<S: State> sealed::Sealed for SetStatus<S> {}
6907 impl<S: State> State for SetStatus<S> {
6908 type Status = Set<members::status>;
6909 type Record = S::Record;
6910 }
6911 pub struct SetRecord<S: State = Empty>(PhantomData<fn() -> S>);
6913 impl<S: State> sealed::Sealed for SetRecord<S> {}
6914 impl<S: State> State for SetRecord<S> {
6915 type Status = S::Status;
6916 type Record = Set<members::record>;
6917 }
6918 #[allow(non_camel_case_types)]
6920 pub mod members {
6921 pub struct status(());
6923 pub struct record(());
6925 }
6926}
6927
6928pub struct StatusViewBuilder<'a, S: status_view_state::State> {
6930 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
6931 __unsafe_private_named: (
6932 ::core::option::Option<crate::app_bsky::embed::external::View<'a>>,
6933 ::core::option::Option<jacquard_common::types::string::Datetime>,
6934 ::core::option::Option<bool>,
6935 ::core::option::Option<jacquard_common::types::value::Data<'a>>,
6936 ::core::option::Option<jacquard_common::CowStr<'a>>,
6937 ),
6938 _phantom: ::core::marker::PhantomData<&'a ()>,
6939}
6940
6941impl<'a> StatusView<'a> {
6942 pub fn new() -> StatusViewBuilder<'a, status_view_state::Empty> {
6944 StatusViewBuilder::new()
6945 }
6946}
6947
6948impl<'a> StatusViewBuilder<'a, status_view_state::Empty> {
6949 pub fn new() -> Self {
6951 StatusViewBuilder {
6952 _phantom_state: ::core::marker::PhantomData,
6953 __unsafe_private_named: (None, None, None, None, None),
6954 _phantom: ::core::marker::PhantomData,
6955 }
6956 }
6957}
6958
6959impl<'a, S: status_view_state::State> StatusViewBuilder<'a, S> {
6960 pub fn embed(
6962 mut self,
6963 value: impl Into<Option<crate::app_bsky::embed::external::View<'a>>>,
6964 ) -> Self {
6965 self.__unsafe_private_named.0 = value.into();
6966 self
6967 }
6968 pub fn maybe_embed(
6970 mut self,
6971 value: Option<crate::app_bsky::embed::external::View<'a>>,
6972 ) -> Self {
6973 self.__unsafe_private_named.0 = value;
6974 self
6975 }
6976}
6977
6978impl<'a, S: status_view_state::State> StatusViewBuilder<'a, S> {
6979 pub fn expires_at(
6981 mut self,
6982 value: impl Into<Option<jacquard_common::types::string::Datetime>>,
6983 ) -> Self {
6984 self.__unsafe_private_named.1 = value.into();
6985 self
6986 }
6987 pub fn maybe_expires_at(
6989 mut self,
6990 value: Option<jacquard_common::types::string::Datetime>,
6991 ) -> Self {
6992 self.__unsafe_private_named.1 = value;
6993 self
6994 }
6995}
6996
6997impl<'a, S: status_view_state::State> StatusViewBuilder<'a, S> {
6998 pub fn is_active(mut self, value: impl Into<Option<bool>>) -> Self {
7000 self.__unsafe_private_named.2 = value.into();
7001 self
7002 }
7003 pub fn maybe_is_active(mut self, value: Option<bool>) -> Self {
7005 self.__unsafe_private_named.2 = value;
7006 self
7007 }
7008}
7009
7010impl<'a, S> StatusViewBuilder<'a, S>
7011where
7012 S: status_view_state::State,
7013 S::Record: status_view_state::IsUnset,
7014{
7015 pub fn record(
7017 mut self,
7018 value: impl Into<jacquard_common::types::value::Data<'a>>,
7019 ) -> StatusViewBuilder<'a, status_view_state::SetRecord<S>> {
7020 self.__unsafe_private_named.3 = ::core::option::Option::Some(value.into());
7021 StatusViewBuilder {
7022 _phantom_state: ::core::marker::PhantomData,
7023 __unsafe_private_named: self.__unsafe_private_named,
7024 _phantom: ::core::marker::PhantomData,
7025 }
7026 }
7027}
7028
7029impl<'a, S> StatusViewBuilder<'a, S>
7030where
7031 S: status_view_state::State,
7032 S::Status: status_view_state::IsUnset,
7033{
7034 pub fn status(
7036 mut self,
7037 value: impl Into<jacquard_common::CowStr<'a>>,
7038 ) -> StatusViewBuilder<'a, status_view_state::SetStatus<S>> {
7039 self.__unsafe_private_named.4 = ::core::option::Option::Some(value.into());
7040 StatusViewBuilder {
7041 _phantom_state: ::core::marker::PhantomData,
7042 __unsafe_private_named: self.__unsafe_private_named,
7043 _phantom: ::core::marker::PhantomData,
7044 }
7045 }
7046}
7047
7048impl<'a, S> StatusViewBuilder<'a, S>
7049where
7050 S: status_view_state::State,
7051 S::Status: status_view_state::IsSet,
7052 S::Record: status_view_state::IsSet,
7053{
7054 pub fn build(self) -> StatusView<'a> {
7056 StatusView {
7057 embed: self.__unsafe_private_named.0,
7058 expires_at: self.__unsafe_private_named.1,
7059 is_active: self.__unsafe_private_named.2,
7060 record: self.__unsafe_private_named.3.unwrap(),
7061 status: self.__unsafe_private_named.4.unwrap(),
7062 extra_data: Default::default(),
7063 }
7064 }
7065 pub fn build_with_data(
7067 self,
7068 extra_data: std::collections::BTreeMap<
7069 jacquard_common::smol_str::SmolStr,
7070 jacquard_common::types::value::Data<'a>,
7071 >,
7072 ) -> StatusView<'a> {
7073 StatusView {
7074 embed: self.__unsafe_private_named.0,
7075 expires_at: self.__unsafe_private_named.1,
7076 is_active: self.__unsafe_private_named.2,
7077 record: self.__unsafe_private_named.3.unwrap(),
7078 status: self.__unsafe_private_named.4.unwrap(),
7079 extra_data: Some(extra_data),
7080 }
7081 }
7082}
7083
7084impl<'a> ::jacquard_lexicon::schema::LexiconSchema for StatusView<'a> {
7085 fn nsid() -> &'static str {
7086 "app.bsky.actor.defs"
7087 }
7088 fn def_name() -> &'static str {
7089 "statusView"
7090 }
7091 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
7092 lexicon_doc_app_bsky_actor_defs()
7093 }
7094 fn validate(
7095 &self,
7096 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
7097 Ok(())
7098 }
7099}
7100
7101#[jacquard_derive::lexicon]
7102#[derive(
7103 serde::Serialize,
7104 serde::Deserialize,
7105 Debug,
7106 Clone,
7107 PartialEq,
7108 Eq,
7109 jacquard_derive::IntoStatic,
7110 Default
7111)]
7112#[serde(rename_all = "camelCase")]
7113pub struct ThreadViewPref<'a> {
7114 #[serde(skip_serializing_if = "std::option::Option::is_none")]
7116 pub prioritize_followed_users: std::option::Option<bool>,
7117 #[serde(skip_serializing_if = "std::option::Option::is_none")]
7119 #[serde(borrow)]
7120 pub sort: std::option::Option<jacquard_common::CowStr<'a>>,
7121}
7122
7123impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ThreadViewPref<'a> {
7124 fn nsid() -> &'static str {
7125 "app.bsky.actor.defs"
7126 }
7127 fn def_name() -> &'static str {
7128 "threadViewPref"
7129 }
7130 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
7131 lexicon_doc_app_bsky_actor_defs()
7132 }
7133 fn validate(
7134 &self,
7135 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
7136 Ok(())
7137 }
7138}
7139
7140#[jacquard_derive::lexicon]
7142#[derive(
7143 serde::Serialize,
7144 serde::Deserialize,
7145 Debug,
7146 Clone,
7147 PartialEq,
7148 Eq,
7149 jacquard_derive::IntoStatic,
7150 Default
7151)]
7152#[serde(rename_all = "camelCase")]
7153pub struct VerificationPrefs<'a> {
7154 #[serde(skip_serializing_if = "std::option::Option::is_none")]
7156 pub hide_badges: std::option::Option<bool>,
7157}
7158
7159impl<'a> ::jacquard_lexicon::schema::LexiconSchema for VerificationPrefs<'a> {
7160 fn nsid() -> &'static str {
7161 "app.bsky.actor.defs"
7162 }
7163 fn def_name() -> &'static str {
7164 "verificationPrefs"
7165 }
7166 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
7167 lexicon_doc_app_bsky_actor_defs()
7168 }
7169 fn validate(
7170 &self,
7171 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
7172 Ok(())
7173 }
7174}
7175
7176#[jacquard_derive::lexicon]
7178#[derive(
7179 serde::Serialize,
7180 serde::Deserialize,
7181 Debug,
7182 Clone,
7183 PartialEq,
7184 Eq,
7185 jacquard_derive::IntoStatic
7186)]
7187#[serde(rename_all = "camelCase")]
7188pub struct VerificationState<'a> {
7189 #[serde(borrow)]
7191 pub trusted_verifier_status: jacquard_common::CowStr<'a>,
7192 #[serde(borrow)]
7194 pub verifications: Vec<crate::app_bsky::actor::VerificationView<'a>>,
7195 #[serde(borrow)]
7197 pub verified_status: jacquard_common::CowStr<'a>,
7198}
7199
7200pub mod verification_state_state {
7201
7202 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
7203 #[allow(unused)]
7204 use ::core::marker::PhantomData;
7205 mod sealed {
7206 pub trait Sealed {}
7207 }
7208 pub trait State: sealed::Sealed {
7210 type Verifications;
7211 type VerifiedStatus;
7212 type TrustedVerifierStatus;
7213 }
7214 pub struct Empty(());
7216 impl sealed::Sealed for Empty {}
7217 impl State for Empty {
7218 type Verifications = Unset;
7219 type VerifiedStatus = Unset;
7220 type TrustedVerifierStatus = Unset;
7221 }
7222 pub struct SetVerifications<S: State = Empty>(PhantomData<fn() -> S>);
7224 impl<S: State> sealed::Sealed for SetVerifications<S> {}
7225 impl<S: State> State for SetVerifications<S> {
7226 type Verifications = Set<members::verifications>;
7227 type VerifiedStatus = S::VerifiedStatus;
7228 type TrustedVerifierStatus = S::TrustedVerifierStatus;
7229 }
7230 pub struct SetVerifiedStatus<S: State = Empty>(PhantomData<fn() -> S>);
7232 impl<S: State> sealed::Sealed for SetVerifiedStatus<S> {}
7233 impl<S: State> State for SetVerifiedStatus<S> {
7234 type Verifications = S::Verifications;
7235 type VerifiedStatus = Set<members::verified_status>;
7236 type TrustedVerifierStatus = S::TrustedVerifierStatus;
7237 }
7238 pub struct SetTrustedVerifierStatus<S: State = Empty>(PhantomData<fn() -> S>);
7240 impl<S: State> sealed::Sealed for SetTrustedVerifierStatus<S> {}
7241 impl<S: State> State for SetTrustedVerifierStatus<S> {
7242 type Verifications = S::Verifications;
7243 type VerifiedStatus = S::VerifiedStatus;
7244 type TrustedVerifierStatus = Set<members::trusted_verifier_status>;
7245 }
7246 #[allow(non_camel_case_types)]
7248 pub mod members {
7249 pub struct verifications(());
7251 pub struct verified_status(());
7253 pub struct trusted_verifier_status(());
7255 }
7256}
7257
7258pub struct VerificationStateBuilder<'a, S: verification_state_state::State> {
7260 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
7261 __unsafe_private_named: (
7262 ::core::option::Option<jacquard_common::CowStr<'a>>,
7263 ::core::option::Option<Vec<crate::app_bsky::actor::VerificationView<'a>>>,
7264 ::core::option::Option<jacquard_common::CowStr<'a>>,
7265 ),
7266 _phantom: ::core::marker::PhantomData<&'a ()>,
7267}
7268
7269impl<'a> VerificationState<'a> {
7270 pub fn new() -> VerificationStateBuilder<'a, verification_state_state::Empty> {
7272 VerificationStateBuilder::new()
7273 }
7274}
7275
7276impl<'a> VerificationStateBuilder<'a, verification_state_state::Empty> {
7277 pub fn new() -> Self {
7279 VerificationStateBuilder {
7280 _phantom_state: ::core::marker::PhantomData,
7281 __unsafe_private_named: (None, None, None),
7282 _phantom: ::core::marker::PhantomData,
7283 }
7284 }
7285}
7286
7287impl<'a, S> VerificationStateBuilder<'a, S>
7288where
7289 S: verification_state_state::State,
7290 S::TrustedVerifierStatus: verification_state_state::IsUnset,
7291{
7292 pub fn trusted_verifier_status(
7294 mut self,
7295 value: impl Into<jacquard_common::CowStr<'a>>,
7296 ) -> VerificationStateBuilder<
7297 'a,
7298 verification_state_state::SetTrustedVerifierStatus<S>,
7299 > {
7300 self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
7301 VerificationStateBuilder {
7302 _phantom_state: ::core::marker::PhantomData,
7303 __unsafe_private_named: self.__unsafe_private_named,
7304 _phantom: ::core::marker::PhantomData,
7305 }
7306 }
7307}
7308
7309impl<'a, S> VerificationStateBuilder<'a, S>
7310where
7311 S: verification_state_state::State,
7312 S::Verifications: verification_state_state::IsUnset,
7313{
7314 pub fn verifications(
7316 mut self,
7317 value: impl Into<Vec<crate::app_bsky::actor::VerificationView<'a>>>,
7318 ) -> VerificationStateBuilder<'a, verification_state_state::SetVerifications<S>> {
7319 self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
7320 VerificationStateBuilder {
7321 _phantom_state: ::core::marker::PhantomData,
7322 __unsafe_private_named: self.__unsafe_private_named,
7323 _phantom: ::core::marker::PhantomData,
7324 }
7325 }
7326}
7327
7328impl<'a, S> VerificationStateBuilder<'a, S>
7329where
7330 S: verification_state_state::State,
7331 S::VerifiedStatus: verification_state_state::IsUnset,
7332{
7333 pub fn verified_status(
7335 mut self,
7336 value: impl Into<jacquard_common::CowStr<'a>>,
7337 ) -> VerificationStateBuilder<'a, verification_state_state::SetVerifiedStatus<S>> {
7338 self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into());
7339 VerificationStateBuilder {
7340 _phantom_state: ::core::marker::PhantomData,
7341 __unsafe_private_named: self.__unsafe_private_named,
7342 _phantom: ::core::marker::PhantomData,
7343 }
7344 }
7345}
7346
7347impl<'a, S> VerificationStateBuilder<'a, S>
7348where
7349 S: verification_state_state::State,
7350 S::Verifications: verification_state_state::IsSet,
7351 S::VerifiedStatus: verification_state_state::IsSet,
7352 S::TrustedVerifierStatus: verification_state_state::IsSet,
7353{
7354 pub fn build(self) -> VerificationState<'a> {
7356 VerificationState {
7357 trusted_verifier_status: self.__unsafe_private_named.0.unwrap(),
7358 verifications: self.__unsafe_private_named.1.unwrap(),
7359 verified_status: self.__unsafe_private_named.2.unwrap(),
7360 extra_data: Default::default(),
7361 }
7362 }
7363 pub fn build_with_data(
7365 self,
7366 extra_data: std::collections::BTreeMap<
7367 jacquard_common::smol_str::SmolStr,
7368 jacquard_common::types::value::Data<'a>,
7369 >,
7370 ) -> VerificationState<'a> {
7371 VerificationState {
7372 trusted_verifier_status: self.__unsafe_private_named.0.unwrap(),
7373 verifications: self.__unsafe_private_named.1.unwrap(),
7374 verified_status: self.__unsafe_private_named.2.unwrap(),
7375 extra_data: Some(extra_data),
7376 }
7377 }
7378}
7379
7380impl<'a> ::jacquard_lexicon::schema::LexiconSchema for VerificationState<'a> {
7381 fn nsid() -> &'static str {
7382 "app.bsky.actor.defs"
7383 }
7384 fn def_name() -> &'static str {
7385 "verificationState"
7386 }
7387 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
7388 lexicon_doc_app_bsky_actor_defs()
7389 }
7390 fn validate(
7391 &self,
7392 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
7393 Ok(())
7394 }
7395}
7396
7397#[jacquard_derive::lexicon]
7399#[derive(
7400 serde::Serialize,
7401 serde::Deserialize,
7402 Debug,
7403 Clone,
7404 PartialEq,
7405 Eq,
7406 jacquard_derive::IntoStatic
7407)]
7408#[serde(rename_all = "camelCase")]
7409pub struct VerificationView<'a> {
7410 pub created_at: jacquard_common::types::string::Datetime,
7412 pub is_valid: bool,
7414 #[serde(borrow)]
7416 pub issuer: jacquard_common::types::string::Did<'a>,
7417 #[serde(borrow)]
7419 pub uri: jacquard_common::types::string::AtUri<'a>,
7420}
7421
7422pub mod verification_view_state {
7423
7424 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
7425 #[allow(unused)]
7426 use ::core::marker::PhantomData;
7427 mod sealed {
7428 pub trait Sealed {}
7429 }
7430 pub trait State: sealed::Sealed {
7432 type Issuer;
7433 type Uri;
7434 type IsValid;
7435 type CreatedAt;
7436 }
7437 pub struct Empty(());
7439 impl sealed::Sealed for Empty {}
7440 impl State for Empty {
7441 type Issuer = Unset;
7442 type Uri = Unset;
7443 type IsValid = Unset;
7444 type CreatedAt = Unset;
7445 }
7446 pub struct SetIssuer<S: State = Empty>(PhantomData<fn() -> S>);
7448 impl<S: State> sealed::Sealed for SetIssuer<S> {}
7449 impl<S: State> State for SetIssuer<S> {
7450 type Issuer = Set<members::issuer>;
7451 type Uri = S::Uri;
7452 type IsValid = S::IsValid;
7453 type CreatedAt = S::CreatedAt;
7454 }
7455 pub struct SetUri<S: State = Empty>(PhantomData<fn() -> S>);
7457 impl<S: State> sealed::Sealed for SetUri<S> {}
7458 impl<S: State> State for SetUri<S> {
7459 type Issuer = S::Issuer;
7460 type Uri = Set<members::uri>;
7461 type IsValid = S::IsValid;
7462 type CreatedAt = S::CreatedAt;
7463 }
7464 pub struct SetIsValid<S: State = Empty>(PhantomData<fn() -> S>);
7466 impl<S: State> sealed::Sealed for SetIsValid<S> {}
7467 impl<S: State> State for SetIsValid<S> {
7468 type Issuer = S::Issuer;
7469 type Uri = S::Uri;
7470 type IsValid = Set<members::is_valid>;
7471 type CreatedAt = S::CreatedAt;
7472 }
7473 pub struct SetCreatedAt<S: State = Empty>(PhantomData<fn() -> S>);
7475 impl<S: State> sealed::Sealed for SetCreatedAt<S> {}
7476 impl<S: State> State for SetCreatedAt<S> {
7477 type Issuer = S::Issuer;
7478 type Uri = S::Uri;
7479 type IsValid = S::IsValid;
7480 type CreatedAt = Set<members::created_at>;
7481 }
7482 #[allow(non_camel_case_types)]
7484 pub mod members {
7485 pub struct issuer(());
7487 pub struct uri(());
7489 pub struct is_valid(());
7491 pub struct created_at(());
7493 }
7494}
7495
7496pub struct VerificationViewBuilder<'a, S: verification_view_state::State> {
7498 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
7499 __unsafe_private_named: (
7500 ::core::option::Option<jacquard_common::types::string::Datetime>,
7501 ::core::option::Option<bool>,
7502 ::core::option::Option<jacquard_common::types::string::Did<'a>>,
7503 ::core::option::Option<jacquard_common::types::string::AtUri<'a>>,
7504 ),
7505 _phantom: ::core::marker::PhantomData<&'a ()>,
7506}
7507
7508impl<'a> VerificationView<'a> {
7509 pub fn new() -> VerificationViewBuilder<'a, verification_view_state::Empty> {
7511 VerificationViewBuilder::new()
7512 }
7513}
7514
7515impl<'a> VerificationViewBuilder<'a, verification_view_state::Empty> {
7516 pub fn new() -> Self {
7518 VerificationViewBuilder {
7519 _phantom_state: ::core::marker::PhantomData,
7520 __unsafe_private_named: (None, None, None, None),
7521 _phantom: ::core::marker::PhantomData,
7522 }
7523 }
7524}
7525
7526impl<'a, S> VerificationViewBuilder<'a, S>
7527where
7528 S: verification_view_state::State,
7529 S::CreatedAt: verification_view_state::IsUnset,
7530{
7531 pub fn created_at(
7533 mut self,
7534 value: impl Into<jacquard_common::types::string::Datetime>,
7535 ) -> VerificationViewBuilder<'a, verification_view_state::SetCreatedAt<S>> {
7536 self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
7537 VerificationViewBuilder {
7538 _phantom_state: ::core::marker::PhantomData,
7539 __unsafe_private_named: self.__unsafe_private_named,
7540 _phantom: ::core::marker::PhantomData,
7541 }
7542 }
7543}
7544
7545impl<'a, S> VerificationViewBuilder<'a, S>
7546where
7547 S: verification_view_state::State,
7548 S::IsValid: verification_view_state::IsUnset,
7549{
7550 pub fn is_valid(
7552 mut self,
7553 value: impl Into<bool>,
7554 ) -> VerificationViewBuilder<'a, verification_view_state::SetIsValid<S>> {
7555 self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
7556 VerificationViewBuilder {
7557 _phantom_state: ::core::marker::PhantomData,
7558 __unsafe_private_named: self.__unsafe_private_named,
7559 _phantom: ::core::marker::PhantomData,
7560 }
7561 }
7562}
7563
7564impl<'a, S> VerificationViewBuilder<'a, S>
7565where
7566 S: verification_view_state::State,
7567 S::Issuer: verification_view_state::IsUnset,
7568{
7569 pub fn issuer(
7571 mut self,
7572 value: impl Into<jacquard_common::types::string::Did<'a>>,
7573 ) -> VerificationViewBuilder<'a, verification_view_state::SetIssuer<S>> {
7574 self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into());
7575 VerificationViewBuilder {
7576 _phantom_state: ::core::marker::PhantomData,
7577 __unsafe_private_named: self.__unsafe_private_named,
7578 _phantom: ::core::marker::PhantomData,
7579 }
7580 }
7581}
7582
7583impl<'a, S> VerificationViewBuilder<'a, S>
7584where
7585 S: verification_view_state::State,
7586 S::Uri: verification_view_state::IsUnset,
7587{
7588 pub fn uri(
7590 mut self,
7591 value: impl Into<jacquard_common::types::string::AtUri<'a>>,
7592 ) -> VerificationViewBuilder<'a, verification_view_state::SetUri<S>> {
7593 self.__unsafe_private_named.3 = ::core::option::Option::Some(value.into());
7594 VerificationViewBuilder {
7595 _phantom_state: ::core::marker::PhantomData,
7596 __unsafe_private_named: self.__unsafe_private_named,
7597 _phantom: ::core::marker::PhantomData,
7598 }
7599 }
7600}
7601
7602impl<'a, S> VerificationViewBuilder<'a, S>
7603where
7604 S: verification_view_state::State,
7605 S::Issuer: verification_view_state::IsSet,
7606 S::Uri: verification_view_state::IsSet,
7607 S::IsValid: verification_view_state::IsSet,
7608 S::CreatedAt: verification_view_state::IsSet,
7609{
7610 pub fn build(self) -> VerificationView<'a> {
7612 VerificationView {
7613 created_at: self.__unsafe_private_named.0.unwrap(),
7614 is_valid: self.__unsafe_private_named.1.unwrap(),
7615 issuer: self.__unsafe_private_named.2.unwrap(),
7616 uri: self.__unsafe_private_named.3.unwrap(),
7617 extra_data: Default::default(),
7618 }
7619 }
7620 pub fn build_with_data(
7622 self,
7623 extra_data: std::collections::BTreeMap<
7624 jacquard_common::smol_str::SmolStr,
7625 jacquard_common::types::value::Data<'a>,
7626 >,
7627 ) -> VerificationView<'a> {
7628 VerificationView {
7629 created_at: self.__unsafe_private_named.0.unwrap(),
7630 is_valid: self.__unsafe_private_named.1.unwrap(),
7631 issuer: self.__unsafe_private_named.2.unwrap(),
7632 uri: self.__unsafe_private_named.3.unwrap(),
7633 extra_data: Some(extra_data),
7634 }
7635 }
7636}
7637
7638impl<'a> ::jacquard_lexicon::schema::LexiconSchema for VerificationView<'a> {
7639 fn nsid() -> &'static str {
7640 "app.bsky.actor.defs"
7641 }
7642 fn def_name() -> &'static str {
7643 "verificationView"
7644 }
7645 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
7646 lexicon_doc_app_bsky_actor_defs()
7647 }
7648 fn validate(
7649 &self,
7650 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
7651 Ok(())
7652 }
7653}
7654
7655#[jacquard_derive::lexicon]
7657#[derive(
7658 serde::Serialize,
7659 serde::Deserialize,
7660 Debug,
7661 Clone,
7662 PartialEq,
7663 Eq,
7664 jacquard_derive::IntoStatic,
7665 Default
7666)]
7667#[serde(rename_all = "camelCase")]
7668pub struct ViewerState<'a> {
7669 #[serde(skip_serializing_if = "std::option::Option::is_none")]
7671 #[serde(borrow)]
7672 pub activity_subscription: std::option::Option<
7673 crate::app_bsky::notification::ActivitySubscription<'a>,
7674 >,
7675 #[serde(skip_serializing_if = "std::option::Option::is_none")]
7676 pub blocked_by: std::option::Option<bool>,
7677 #[serde(skip_serializing_if = "std::option::Option::is_none")]
7678 #[serde(borrow)]
7679 pub blocking: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
7680 #[serde(skip_serializing_if = "std::option::Option::is_none")]
7681 #[serde(borrow)]
7682 pub blocking_by_list: std::option::Option<crate::app_bsky::graph::ListViewBasic<'a>>,
7683 #[serde(skip_serializing_if = "std::option::Option::is_none")]
7684 #[serde(borrow)]
7685 pub followed_by: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
7686 #[serde(skip_serializing_if = "std::option::Option::is_none")]
7687 #[serde(borrow)]
7688 pub following: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
7689 #[serde(skip_serializing_if = "std::option::Option::is_none")]
7691 #[serde(borrow)]
7692 pub known_followers: std::option::Option<crate::app_bsky::actor::KnownFollowers<'a>>,
7693 #[serde(skip_serializing_if = "std::option::Option::is_none")]
7694 pub muted: std::option::Option<bool>,
7695 #[serde(skip_serializing_if = "std::option::Option::is_none")]
7696 #[serde(borrow)]
7697 pub muted_by_list: std::option::Option<crate::app_bsky::graph::ListViewBasic<'a>>,
7698}
7699
7700impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ViewerState<'a> {
7701 fn nsid() -> &'static str {
7702 "app.bsky.actor.defs"
7703 }
7704 fn def_name() -> &'static str {
7705 "viewerState"
7706 }
7707 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
7708 lexicon_doc_app_bsky_actor_defs()
7709 }
7710 fn validate(
7711 &self,
7712 ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
7713 Ok(())
7714 }
7715}