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