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(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
20#[serde(rename_all = "camelCase")]
21pub struct AdultContentPref<'a> {
22 pub enabled: bool,
23}
24
25impl jacquard_common::IntoStatic for AdultContentPref<'_> {
26 type Output = AdultContentPref<'static>;
27 fn into_static(self) -> Self::Output {
28 AdultContentPref {
29 enabled: self.enabled.into_static(),
30 extra_data: self.extra_data.into_static(),
31 }
32 }
33}
34
35#[jacquard_derive::lexicon]
37#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
38#[serde(rename_all = "camelCase")]
39pub struct BskyAppProgressGuide<'a> {
40 #[serde(borrow)]
41 pub guide: jacquard_common::CowStr<'a>,
42}
43
44impl jacquard_common::IntoStatic for BskyAppProgressGuide<'_> {
45 type Output = BskyAppProgressGuide<'static>;
46 fn into_static(self) -> Self::Output {
47 BskyAppProgressGuide {
48 guide: self.guide.into_static(),
49 extra_data: self.extra_data.into_static(),
50 }
51 }
52}
53
54#[jacquard_derive::lexicon]
56#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
57#[serde(rename_all = "camelCase")]
58pub struct BskyAppStatePref<'a> {
59 #[serde(skip_serializing_if = "std::option::Option::is_none")]
60 #[serde(borrow)]
61 pub active_progress_guide: std::option::Option<
62 crate::app_bsky::actor::BskyAppProgressGuide<'a>,
63 >,
64 #[serde(skip_serializing_if = "std::option::Option::is_none")]
66 #[serde(borrow)]
67 pub nuxs: std::option::Option<Vec<crate::app_bsky::actor::Nux<'a>>>,
68 #[serde(skip_serializing_if = "std::option::Option::is_none")]
70 #[serde(borrow)]
71 pub queued_nudges: std::option::Option<Vec<jacquard_common::CowStr<'a>>>,
72}
73
74impl jacquard_common::IntoStatic for BskyAppStatePref<'_> {
75 type Output = BskyAppStatePref<'static>;
76 fn into_static(self) -> Self::Output {
77 BskyAppStatePref {
78 active_progress_guide: self.active_progress_guide.into_static(),
79 nuxs: self.nuxs.into_static(),
80 queued_nudges: self.queued_nudges.into_static(),
81 extra_data: self.extra_data.into_static(),
82 }
83 }
84}
85
86#[jacquard_derive::lexicon]
87#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
88#[serde(rename_all = "camelCase")]
89pub struct ContentLabelPref<'a> {
90 #[serde(borrow)]
91 pub label: jacquard_common::CowStr<'a>,
92 #[serde(skip_serializing_if = "std::option::Option::is_none")]
94 #[serde(borrow)]
95 pub labeler_did: std::option::Option<jacquard_common::types::string::Did<'a>>,
96 #[serde(borrow)]
97 pub visibility: jacquard_common::CowStr<'a>,
98}
99
100impl jacquard_common::IntoStatic for ContentLabelPref<'_> {
101 type Output = ContentLabelPref<'static>;
102 fn into_static(self) -> Self::Output {
103 ContentLabelPref {
104 label: self.label.into_static(),
105 labeler_did: self.labeler_did.into_static(),
106 visibility: self.visibility.into_static(),
107 extra_data: self.extra_data.into_static(),
108 }
109 }
110}
111
112#[jacquard_derive::lexicon]
113#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
114#[serde(rename_all = "camelCase")]
115pub struct FeedViewPref<'a> {
116 #[serde(borrow)]
118 pub feed: jacquard_common::CowStr<'a>,
119 #[serde(skip_serializing_if = "std::option::Option::is_none")]
121 pub hide_quote_posts: std::option::Option<bool>,
122 #[serde(skip_serializing_if = "std::option::Option::is_none")]
124 pub hide_replies: std::option::Option<bool>,
125 #[serde(skip_serializing_if = "std::option::Option::is_none")]
127 pub hide_replies_by_like_count: std::option::Option<i64>,
128 #[serde(skip_serializing_if = "std::option::Option::is_none")]
130 pub hide_replies_by_unfollowed: std::option::Option<bool>,
131 #[serde(skip_serializing_if = "std::option::Option::is_none")]
133 pub hide_reposts: std::option::Option<bool>,
134}
135
136impl jacquard_common::IntoStatic for FeedViewPref<'_> {
137 type Output = FeedViewPref<'static>;
138 fn into_static(self) -> Self::Output {
139 FeedViewPref {
140 feed: self.feed.into_static(),
141 hide_quote_posts: self.hide_quote_posts.into_static(),
142 hide_replies: self.hide_replies.into_static(),
143 hide_replies_by_like_count: self.hide_replies_by_like_count.into_static(),
144 hide_replies_by_unfollowed: self.hide_replies_by_unfollowed.into_static(),
145 hide_reposts: self.hide_reposts.into_static(),
146 extra_data: self.extra_data.into_static(),
147 }
148 }
149}
150
151#[jacquard_derive::lexicon]
152#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
153#[serde(rename_all = "camelCase")]
154pub struct HiddenPostsPref<'a> {
155 #[serde(borrow)]
157 pub items: Vec<jacquard_common::types::string::AtUri<'a>>,
158}
159
160impl jacquard_common::IntoStatic for HiddenPostsPref<'_> {
161 type Output = HiddenPostsPref<'static>;
162 fn into_static(self) -> Self::Output {
163 HiddenPostsPref {
164 items: self.items.into_static(),
165 extra_data: self.extra_data.into_static(),
166 }
167 }
168}
169
170#[jacquard_derive::lexicon]
171#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
172#[serde(rename_all = "camelCase")]
173pub struct InterestsPref<'a> {
174 #[serde(borrow)]
176 pub tags: Vec<jacquard_common::CowStr<'a>>,
177}
178
179impl jacquard_common::IntoStatic for InterestsPref<'_> {
180 type Output = InterestsPref<'static>;
181 fn into_static(self) -> Self::Output {
182 InterestsPref {
183 tags: self.tags.into_static(),
184 extra_data: self.extra_data.into_static(),
185 }
186 }
187}
188
189#[jacquard_derive::lexicon]
191#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
192#[serde(rename_all = "camelCase")]
193pub struct KnownFollowers<'a> {
194 pub count: i64,
195 #[serde(borrow)]
196 pub followers: Vec<crate::app_bsky::actor::ProfileViewBasic<'a>>,
197}
198
199impl jacquard_common::IntoStatic for KnownFollowers<'_> {
200 type Output = KnownFollowers<'static>;
201 fn into_static(self) -> Self::Output {
202 KnownFollowers {
203 count: self.count.into_static(),
204 followers: self.followers.into_static(),
205 extra_data: self.extra_data.into_static(),
206 }
207 }
208}
209
210#[jacquard_derive::lexicon]
211#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
212#[serde(rename_all = "camelCase")]
213pub struct LabelerPrefItem<'a> {
214 #[serde(borrow)]
215 pub did: jacquard_common::types::string::Did<'a>,
216}
217
218impl jacquard_common::IntoStatic for LabelerPrefItem<'_> {
219 type Output = LabelerPrefItem<'static>;
220 fn into_static(self) -> Self::Output {
221 LabelerPrefItem {
222 did: self.did.into_static(),
223 extra_data: self.extra_data.into_static(),
224 }
225 }
226}
227
228#[jacquard_derive::lexicon]
229#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
230#[serde(rename_all = "camelCase")]
231pub struct LabelersPref<'a> {
232 #[serde(borrow)]
233 pub labelers: Vec<crate::app_bsky::actor::LabelerPrefItem<'a>>,
234}
235
236impl jacquard_common::IntoStatic for LabelersPref<'_> {
237 type Output = LabelersPref<'static>;
238 fn into_static(self) -> Self::Output {
239 LabelersPref {
240 labelers: self.labelers.into_static(),
241 extra_data: self.extra_data.into_static(),
242 }
243 }
244}
245
246#[jacquard_derive::lexicon]
248#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
249#[serde(rename_all = "camelCase")]
250pub struct MutedWord<'a> {
251 #[serde(skip_serializing_if = "std::option::Option::is_none")]
253 #[serde(borrow)]
254 pub actor_target: std::option::Option<jacquard_common::CowStr<'a>>,
255 #[serde(skip_serializing_if = "std::option::Option::is_none")]
257 pub expires_at: std::option::Option<jacquard_common::types::string::Datetime>,
258 #[serde(skip_serializing_if = "std::option::Option::is_none")]
259 #[serde(borrow)]
260 pub id: std::option::Option<jacquard_common::CowStr<'a>>,
261 #[serde(borrow)]
263 pub targets: Vec<crate::app_bsky::actor::MutedWordTarget<'a>>,
264 #[serde(borrow)]
266 pub value: jacquard_common::CowStr<'a>,
267}
268
269impl jacquard_common::IntoStatic for MutedWord<'_> {
270 type Output = MutedWord<'static>;
271 fn into_static(self) -> Self::Output {
272 MutedWord {
273 actor_target: self.actor_target.into_static(),
274 expires_at: self.expires_at.into_static(),
275 id: self.id.into_static(),
276 targets: self.targets.into_static(),
277 value: self.value.into_static(),
278 extra_data: self.extra_data.into_static(),
279 }
280 }
281}
282
283#[derive(Debug, Clone, PartialEq, Eq, Hash)]
284pub enum MutedWordTarget<'a> {
285 Content,
286 Tag,
287 Other(jacquard_common::CowStr<'a>),
288}
289
290impl<'a> MutedWordTarget<'a> {
291 pub fn as_str(&self) -> &str {
292 match self {
293 Self::Content => "content",
294 Self::Tag => "tag",
295 Self::Other(s) => s.as_ref(),
296 }
297 }
298}
299
300impl<'a> From<&'a str> for MutedWordTarget<'a> {
301 fn from(s: &'a str) -> Self {
302 match s {
303 "content" => Self::Content,
304 "tag" => Self::Tag,
305 _ => Self::Other(jacquard_common::CowStr::from(s)),
306 }
307 }
308}
309
310impl<'a> From<String> for MutedWordTarget<'a> {
311 fn from(s: String) -> Self {
312 match s.as_str() {
313 "content" => Self::Content,
314 "tag" => Self::Tag,
315 _ => Self::Other(jacquard_common::CowStr::from(s)),
316 }
317 }
318}
319
320impl<'a> AsRef<str> for MutedWordTarget<'a> {
321 fn as_ref(&self) -> &str {
322 self.as_str()
323 }
324}
325
326impl<'a> serde::Serialize for MutedWordTarget<'a> {
327 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
328 where
329 S: serde::Serializer,
330 {
331 serializer.serialize_str(self.as_str())
332 }
333}
334
335impl<'de, 'a> serde::Deserialize<'de> for MutedWordTarget<'a>
336where
337 'de: 'a,
338{
339 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
340 where
341 D: serde::Deserializer<'de>,
342 {
343 let s = <&'de str>::deserialize(deserializer)?;
344 Ok(Self::from(s))
345 }
346}
347
348impl jacquard_common::IntoStatic for MutedWordTarget<'_> {
349 type Output = MutedWordTarget<'static>;
350 fn into_static(self) -> Self::Output {
351 match self {
352 MutedWordTarget::Content => MutedWordTarget::Content,
353 MutedWordTarget::Tag => MutedWordTarget::Tag,
354 MutedWordTarget::Other(v) => MutedWordTarget::Other(v.into_static()),
355 }
356 }
357}
358
359#[jacquard_derive::lexicon]
360#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
361#[serde(rename_all = "camelCase")]
362pub struct MutedWordsPref<'a> {
363 #[serde(borrow)]
365 pub items: Vec<crate::app_bsky::actor::MutedWord<'a>>,
366}
367
368impl jacquard_common::IntoStatic for MutedWordsPref<'_> {
369 type Output = MutedWordsPref<'static>;
370 fn into_static(self) -> Self::Output {
371 MutedWordsPref {
372 items: self.items.into_static(),
373 extra_data: self.extra_data.into_static(),
374 }
375 }
376}
377
378#[jacquard_derive::lexicon]
380#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
381#[serde(rename_all = "camelCase")]
382pub struct Nux<'a> {
383 pub completed: bool,
384 #[serde(skip_serializing_if = "std::option::Option::is_none")]
386 #[serde(borrow)]
387 pub data: std::option::Option<jacquard_common::CowStr<'a>>,
388 #[serde(skip_serializing_if = "std::option::Option::is_none")]
390 pub expires_at: std::option::Option<jacquard_common::types::string::Datetime>,
391 #[serde(borrow)]
392 pub id: jacquard_common::CowStr<'a>,
393}
394
395impl jacquard_common::IntoStatic for Nux<'_> {
396 type Output = Nux<'static>;
397 fn into_static(self) -> Self::Output {
398 Nux {
399 completed: self.completed.into_static(),
400 data: self.data.into_static(),
401 expires_at: self.expires_at.into_static(),
402 id: self.id.into_static(),
403 extra_data: self.extra_data.into_static(),
404 }
405 }
406}
407
408#[jacquard_derive::lexicon]
409#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
410#[serde(rename_all = "camelCase")]
411pub struct PersonalDetailsPref<'a> {
412 #[serde(skip_serializing_if = "std::option::Option::is_none")]
414 pub birth_date: std::option::Option<jacquard_common::types::string::Datetime>,
415}
416
417impl jacquard_common::IntoStatic for PersonalDetailsPref<'_> {
418 type Output = PersonalDetailsPref<'static>;
419 fn into_static(self) -> Self::Output {
420 PersonalDetailsPref {
421 birth_date: self.birth_date.into_static(),
422 extra_data: self.extra_data.into_static(),
423 }
424 }
425}
426
427#[jacquard_derive::lexicon]
429#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
430#[serde(rename_all = "camelCase")]
431pub struct PostInteractionSettingsPref<'a> {
432 #[serde(skip_serializing_if = "std::option::Option::is_none")]
434 #[serde(borrow)]
435 pub postgate_embedding_rules: std::option::Option<
436 Vec<jacquard_common::types::value::Data<'a>>,
437 >,
438 #[serde(skip_serializing_if = "std::option::Option::is_none")]
440 #[serde(borrow)]
441 pub threadgate_allow_rules: std::option::Option<
442 Vec<jacquard_common::types::value::Data<'a>>,
443 >,
444}
445
446impl jacquard_common::IntoStatic for PostInteractionSettingsPref<'_> {
447 type Output = PostInteractionSettingsPref<'static>;
448 fn into_static(self) -> Self::Output {
449 PostInteractionSettingsPref {
450 postgate_embedding_rules: self.postgate_embedding_rules.into_static(),
451 threadgate_allow_rules: self.threadgate_allow_rules.into_static(),
452 extra_data: self.extra_data.into_static(),
453 }
454 }
455}
456
457pub type Preferences<'a> = Vec<jacquard_common::types::value::Data<'a>>;
458#[jacquard_derive::lexicon]
459#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
460#[serde(rename_all = "camelCase")]
461pub struct ProfileAssociated<'a> {
462 #[serde(skip_serializing_if = "std::option::Option::is_none")]
463 #[serde(borrow)]
464 pub activity_subscription: std::option::Option<
465 crate::app_bsky::actor::ProfileAssociatedActivitySubscription<'a>,
466 >,
467 #[serde(skip_serializing_if = "std::option::Option::is_none")]
468 #[serde(borrow)]
469 pub chat: std::option::Option<crate::app_bsky::actor::ProfileAssociatedChat<'a>>,
470 #[serde(skip_serializing_if = "std::option::Option::is_none")]
471 pub feedgens: std::option::Option<i64>,
472 #[serde(skip_serializing_if = "std::option::Option::is_none")]
473 pub labeler: std::option::Option<bool>,
474 #[serde(skip_serializing_if = "std::option::Option::is_none")]
475 pub lists: std::option::Option<i64>,
476 #[serde(skip_serializing_if = "std::option::Option::is_none")]
477 pub starter_packs: std::option::Option<i64>,
478}
479
480impl jacquard_common::IntoStatic for ProfileAssociated<'_> {
481 type Output = ProfileAssociated<'static>;
482 fn into_static(self) -> Self::Output {
483 ProfileAssociated {
484 activity_subscription: self.activity_subscription.into_static(),
485 chat: self.chat.into_static(),
486 feedgens: self.feedgens.into_static(),
487 labeler: self.labeler.into_static(),
488 lists: self.lists.into_static(),
489 starter_packs: self.starter_packs.into_static(),
490 extra_data: self.extra_data.into_static(),
491 }
492 }
493}
494
495#[jacquard_derive::lexicon]
496#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
497#[serde(rename_all = "camelCase")]
498pub struct ProfileAssociatedActivitySubscription<'a> {
499 #[serde(borrow)]
500 pub allow_subscriptions: jacquard_common::CowStr<'a>,
501}
502
503impl jacquard_common::IntoStatic for ProfileAssociatedActivitySubscription<'_> {
504 type Output = ProfileAssociatedActivitySubscription<'static>;
505 fn into_static(self) -> Self::Output {
506 ProfileAssociatedActivitySubscription {
507 allow_subscriptions: self.allow_subscriptions.into_static(),
508 extra_data: self.extra_data.into_static(),
509 }
510 }
511}
512
513#[jacquard_derive::lexicon]
514#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
515#[serde(rename_all = "camelCase")]
516pub struct ProfileAssociatedChat<'a> {
517 #[serde(borrow)]
518 pub allow_incoming: jacquard_common::CowStr<'a>,
519}
520
521impl jacquard_common::IntoStatic for ProfileAssociatedChat<'_> {
522 type Output = ProfileAssociatedChat<'static>;
523 fn into_static(self) -> Self::Output {
524 ProfileAssociatedChat {
525 allow_incoming: self.allow_incoming.into_static(),
526 extra_data: self.extra_data.into_static(),
527 }
528 }
529}
530
531#[jacquard_derive::lexicon]
532#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
533#[serde(rename_all = "camelCase")]
534pub struct ProfileView<'a> {
535 #[serde(skip_serializing_if = "std::option::Option::is_none")]
536 #[serde(borrow)]
537 pub associated: std::option::Option<crate::app_bsky::actor::ProfileAssociated<'a>>,
538 #[serde(skip_serializing_if = "std::option::Option::is_none")]
539 #[serde(borrow)]
540 pub avatar: std::option::Option<jacquard_common::types::string::Uri<'a>>,
541 #[serde(skip_serializing_if = "std::option::Option::is_none")]
542 pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,
543 #[serde(skip_serializing_if = "std::option::Option::is_none")]
544 #[serde(borrow)]
545 pub description: std::option::Option<jacquard_common::CowStr<'a>>,
546 #[serde(borrow)]
547 pub did: jacquard_common::types::string::Did<'a>,
548 #[serde(skip_serializing_if = "std::option::Option::is_none")]
549 #[serde(borrow)]
550 pub display_name: std::option::Option<jacquard_common::CowStr<'a>>,
551 #[serde(borrow)]
552 pub handle: jacquard_common::types::string::Handle<'a>,
553 #[serde(skip_serializing_if = "std::option::Option::is_none")]
554 pub indexed_at: std::option::Option<jacquard_common::types::string::Datetime>,
555 #[serde(skip_serializing_if = "std::option::Option::is_none")]
556 #[serde(borrow)]
557 pub labels: std::option::Option<Vec<crate::com_atproto::label::Label<'a>>>,
558 #[serde(skip_serializing_if = "std::option::Option::is_none")]
559 #[serde(borrow)]
560 pub pronouns: std::option::Option<jacquard_common::CowStr<'a>>,
561 #[serde(skip_serializing_if = "std::option::Option::is_none")]
562 #[serde(borrow)]
563 pub status: std::option::Option<crate::app_bsky::actor::StatusView<'a>>,
564 #[serde(skip_serializing_if = "std::option::Option::is_none")]
565 #[serde(borrow)]
566 pub verification: std::option::Option<crate::app_bsky::actor::VerificationState<'a>>,
567 #[serde(skip_serializing_if = "std::option::Option::is_none")]
568 #[serde(borrow)]
569 pub viewer: std::option::Option<crate::app_bsky::actor::ViewerState<'a>>,
570}
571
572impl jacquard_common::IntoStatic for ProfileView<'_> {
573 type Output = ProfileView<'static>;
574 fn into_static(self) -> Self::Output {
575 ProfileView {
576 associated: self.associated.into_static(),
577 avatar: self.avatar.into_static(),
578 created_at: self.created_at.into_static(),
579 description: self.description.into_static(),
580 did: self.did.into_static(),
581 display_name: self.display_name.into_static(),
582 handle: self.handle.into_static(),
583 indexed_at: self.indexed_at.into_static(),
584 labels: self.labels.into_static(),
585 pronouns: self.pronouns.into_static(),
586 status: self.status.into_static(),
587 verification: self.verification.into_static(),
588 viewer: self.viewer.into_static(),
589 extra_data: self.extra_data.into_static(),
590 }
591 }
592}
593
594#[jacquard_derive::lexicon]
595#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
596#[serde(rename_all = "camelCase")]
597pub struct ProfileViewBasic<'a> {
598 #[serde(skip_serializing_if = "std::option::Option::is_none")]
599 #[serde(borrow)]
600 pub associated: std::option::Option<crate::app_bsky::actor::ProfileAssociated<'a>>,
601 #[serde(skip_serializing_if = "std::option::Option::is_none")]
602 #[serde(borrow)]
603 pub avatar: std::option::Option<jacquard_common::types::string::Uri<'a>>,
604 #[serde(skip_serializing_if = "std::option::Option::is_none")]
605 pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,
606 #[serde(borrow)]
607 pub did: jacquard_common::types::string::Did<'a>,
608 #[serde(skip_serializing_if = "std::option::Option::is_none")]
609 #[serde(borrow)]
610 pub display_name: std::option::Option<jacquard_common::CowStr<'a>>,
611 #[serde(borrow)]
612 pub handle: jacquard_common::types::string::Handle<'a>,
613 #[serde(skip_serializing_if = "std::option::Option::is_none")]
614 #[serde(borrow)]
615 pub labels: std::option::Option<Vec<crate::com_atproto::label::Label<'a>>>,
616 #[serde(skip_serializing_if = "std::option::Option::is_none")]
617 #[serde(borrow)]
618 pub pronouns: std::option::Option<jacquard_common::CowStr<'a>>,
619 #[serde(skip_serializing_if = "std::option::Option::is_none")]
620 #[serde(borrow)]
621 pub status: std::option::Option<crate::app_bsky::actor::StatusView<'a>>,
622 #[serde(skip_serializing_if = "std::option::Option::is_none")]
623 #[serde(borrow)]
624 pub verification: std::option::Option<crate::app_bsky::actor::VerificationState<'a>>,
625 #[serde(skip_serializing_if = "std::option::Option::is_none")]
626 #[serde(borrow)]
627 pub viewer: std::option::Option<crate::app_bsky::actor::ViewerState<'a>>,
628}
629
630impl jacquard_common::IntoStatic for ProfileViewBasic<'_> {
631 type Output = ProfileViewBasic<'static>;
632 fn into_static(self) -> Self::Output {
633 ProfileViewBasic {
634 associated: self.associated.into_static(),
635 avatar: self.avatar.into_static(),
636 created_at: self.created_at.into_static(),
637 did: self.did.into_static(),
638 display_name: self.display_name.into_static(),
639 handle: self.handle.into_static(),
640 labels: self.labels.into_static(),
641 pronouns: self.pronouns.into_static(),
642 status: self.status.into_static(),
643 verification: self.verification.into_static(),
644 viewer: self.viewer.into_static(),
645 extra_data: self.extra_data.into_static(),
646 }
647 }
648}
649
650#[jacquard_derive::lexicon]
651#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
652#[serde(rename_all = "camelCase")]
653pub struct ProfileViewDetailed<'a> {
654 #[serde(skip_serializing_if = "std::option::Option::is_none")]
655 #[serde(borrow)]
656 pub associated: std::option::Option<crate::app_bsky::actor::ProfileAssociated<'a>>,
657 #[serde(skip_serializing_if = "std::option::Option::is_none")]
658 #[serde(borrow)]
659 pub avatar: std::option::Option<jacquard_common::types::string::Uri<'a>>,
660 #[serde(skip_serializing_if = "std::option::Option::is_none")]
661 #[serde(borrow)]
662 pub banner: std::option::Option<jacquard_common::types::string::Uri<'a>>,
663 #[serde(skip_serializing_if = "std::option::Option::is_none")]
664 pub created_at: std::option::Option<jacquard_common::types::string::Datetime>,
665 #[serde(skip_serializing_if = "std::option::Option::is_none")]
666 #[serde(borrow)]
667 pub description: std::option::Option<jacquard_common::CowStr<'a>>,
668 #[serde(borrow)]
669 pub did: jacquard_common::types::string::Did<'a>,
670 #[serde(skip_serializing_if = "std::option::Option::is_none")]
671 #[serde(borrow)]
672 pub display_name: std::option::Option<jacquard_common::CowStr<'a>>,
673 #[serde(skip_serializing_if = "std::option::Option::is_none")]
674 pub followers_count: std::option::Option<i64>,
675 #[serde(skip_serializing_if = "std::option::Option::is_none")]
676 pub follows_count: std::option::Option<i64>,
677 #[serde(borrow)]
678 pub handle: jacquard_common::types::string::Handle<'a>,
679 #[serde(skip_serializing_if = "std::option::Option::is_none")]
680 pub indexed_at: std::option::Option<jacquard_common::types::string::Datetime>,
681 #[serde(skip_serializing_if = "std::option::Option::is_none")]
682 #[serde(borrow)]
683 pub joined_via_starter_pack: std::option::Option<
684 crate::app_bsky::graph::StarterPackViewBasic<'a>,
685 >,
686 #[serde(skip_serializing_if = "std::option::Option::is_none")]
687 #[serde(borrow)]
688 pub labels: std::option::Option<Vec<crate::com_atproto::label::Label<'a>>>,
689 #[serde(skip_serializing_if = "std::option::Option::is_none")]
690 #[serde(borrow)]
691 pub pinned_post: std::option::Option<
692 crate::com_atproto::repo::strong_ref::StrongRef<'a>,
693 >,
694 #[serde(skip_serializing_if = "std::option::Option::is_none")]
695 pub posts_count: std::option::Option<i64>,
696 #[serde(skip_serializing_if = "std::option::Option::is_none")]
697 #[serde(borrow)]
698 pub pronouns: std::option::Option<jacquard_common::CowStr<'a>>,
699 #[serde(skip_serializing_if = "std::option::Option::is_none")]
700 #[serde(borrow)]
701 pub status: std::option::Option<crate::app_bsky::actor::StatusView<'a>>,
702 #[serde(skip_serializing_if = "std::option::Option::is_none")]
703 #[serde(borrow)]
704 pub verification: std::option::Option<crate::app_bsky::actor::VerificationState<'a>>,
705 #[serde(skip_serializing_if = "std::option::Option::is_none")]
706 #[serde(borrow)]
707 pub viewer: std::option::Option<crate::app_bsky::actor::ViewerState<'a>>,
708 #[serde(skip_serializing_if = "std::option::Option::is_none")]
709 #[serde(borrow)]
710 pub website: std::option::Option<jacquard_common::types::string::Uri<'a>>,
711}
712
713impl jacquard_common::IntoStatic for ProfileViewDetailed<'_> {
714 type Output = ProfileViewDetailed<'static>;
715 fn into_static(self) -> Self::Output {
716 ProfileViewDetailed {
717 associated: self.associated.into_static(),
718 avatar: self.avatar.into_static(),
719 banner: self.banner.into_static(),
720 created_at: self.created_at.into_static(),
721 description: self.description.into_static(),
722 did: self.did.into_static(),
723 display_name: self.display_name.into_static(),
724 followers_count: self.followers_count.into_static(),
725 follows_count: self.follows_count.into_static(),
726 handle: self.handle.into_static(),
727 indexed_at: self.indexed_at.into_static(),
728 joined_via_starter_pack: self.joined_via_starter_pack.into_static(),
729 labels: self.labels.into_static(),
730 pinned_post: self.pinned_post.into_static(),
731 posts_count: self.posts_count.into_static(),
732 pronouns: self.pronouns.into_static(),
733 status: self.status.into_static(),
734 verification: self.verification.into_static(),
735 viewer: self.viewer.into_static(),
736 website: self.website.into_static(),
737 extra_data: self.extra_data.into_static(),
738 }
739 }
740}
741
742#[jacquard_derive::lexicon]
743#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
744#[serde(rename_all = "camelCase")]
745pub struct SavedFeed<'a> {
746 #[serde(borrow)]
747 pub id: jacquard_common::CowStr<'a>,
748 pub pinned: bool,
749 #[serde(borrow)]
750 pub r#type: jacquard_common::CowStr<'a>,
751 #[serde(borrow)]
752 pub value: jacquard_common::CowStr<'a>,
753}
754
755impl jacquard_common::IntoStatic for SavedFeed<'_> {
756 type Output = SavedFeed<'static>;
757 fn into_static(self) -> Self::Output {
758 SavedFeed {
759 id: self.id.into_static(),
760 pinned: self.pinned.into_static(),
761 r#type: self.r#type.into_static(),
762 value: self.value.into_static(),
763 extra_data: self.extra_data.into_static(),
764 }
765 }
766}
767
768#[jacquard_derive::lexicon]
769#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
770#[serde(rename_all = "camelCase")]
771pub struct SavedFeedsPref<'a> {
772 #[serde(borrow)]
773 pub pinned: Vec<jacquard_common::types::string::AtUri<'a>>,
774 #[serde(borrow)]
775 pub saved: Vec<jacquard_common::types::string::AtUri<'a>>,
776 #[serde(skip_serializing_if = "std::option::Option::is_none")]
777 pub timeline_index: std::option::Option<i64>,
778}
779
780impl jacquard_common::IntoStatic for SavedFeedsPref<'_> {
781 type Output = SavedFeedsPref<'static>;
782 fn into_static(self) -> Self::Output {
783 SavedFeedsPref {
784 pinned: self.pinned.into_static(),
785 saved: self.saved.into_static(),
786 timeline_index: self.timeline_index.into_static(),
787 extra_data: self.extra_data.into_static(),
788 }
789 }
790}
791
792#[jacquard_derive::lexicon]
793#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
794#[serde(rename_all = "camelCase")]
795pub struct SavedFeedsPrefV2<'a> {
796 #[serde(borrow)]
797 pub items: Vec<crate::app_bsky::actor::SavedFeed<'a>>,
798}
799
800impl jacquard_common::IntoStatic for SavedFeedsPrefV2<'_> {
801 type Output = SavedFeedsPrefV2<'static>;
802 fn into_static(self) -> Self::Output {
803 SavedFeedsPrefV2 {
804 items: self.items.into_static(),
805 extra_data: self.extra_data.into_static(),
806 }
807 }
808}
809
810#[jacquard_derive::lexicon]
811#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
812#[serde(rename_all = "camelCase")]
813pub struct StatusView<'a> {
814 #[serde(skip_serializing_if = "std::option::Option::is_none")]
816 #[serde(borrow)]
817 pub embed: std::option::Option<StatusViewRecordEmbed<'a>>,
818 #[serde(skip_serializing_if = "std::option::Option::is_none")]
820 pub expires_at: std::option::Option<jacquard_common::types::string::Datetime>,
821 #[serde(skip_serializing_if = "std::option::Option::is_none")]
823 pub is_active: std::option::Option<bool>,
824 #[serde(borrow)]
825 pub record: jacquard_common::types::value::Data<'a>,
826 #[serde(borrow)]
828 pub status: jacquard_common::CowStr<'a>,
829}
830
831#[jacquard_derive::open_union]
832#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
833#[serde(tag = "$type")]
834#[serde(bound(deserialize = "'de: 'a"))]
835pub enum StatusViewRecordEmbed<'a> {
836 #[serde(rename = "app.bsky.embed.external#view")]
837 ExternalView(Box<crate::app_bsky::embed::external::View<'a>>),
838}
839
840impl jacquard_common::IntoStatic for StatusViewRecordEmbed<'_> {
841 type Output = StatusViewRecordEmbed<'static>;
842 fn into_static(self) -> Self::Output {
843 match self {
844 StatusViewRecordEmbed::ExternalView(v) => {
845 StatusViewRecordEmbed::ExternalView(v.into_static())
846 }
847 StatusViewRecordEmbed::Unknown(v) => {
848 StatusViewRecordEmbed::Unknown(v.into_static())
849 }
850 }
851 }
852}
853
854impl jacquard_common::IntoStatic for StatusView<'_> {
855 type Output = StatusView<'static>;
856 fn into_static(self) -> Self::Output {
857 StatusView {
858 embed: self.embed.into_static(),
859 expires_at: self.expires_at.into_static(),
860 is_active: self.is_active.into_static(),
861 record: self.record.into_static(),
862 status: self.status.into_static(),
863 extra_data: self.extra_data.into_static(),
864 }
865 }
866}
867
868#[jacquard_derive::lexicon]
869#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
870#[serde(rename_all = "camelCase")]
871pub struct ThreadViewPref<'a> {
872 #[serde(skip_serializing_if = "std::option::Option::is_none")]
874 pub prioritize_followed_users: std::option::Option<bool>,
875 #[serde(skip_serializing_if = "std::option::Option::is_none")]
877 #[serde(borrow)]
878 pub sort: std::option::Option<jacquard_common::CowStr<'a>>,
879}
880
881impl jacquard_common::IntoStatic for ThreadViewPref<'_> {
882 type Output = ThreadViewPref<'static>;
883 fn into_static(self) -> Self::Output {
884 ThreadViewPref {
885 prioritize_followed_users: self.prioritize_followed_users.into_static(),
886 sort: self.sort.into_static(),
887 extra_data: self.extra_data.into_static(),
888 }
889 }
890}
891
892#[jacquard_derive::lexicon]
894#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
895#[serde(rename_all = "camelCase")]
896pub struct VerificationPrefs<'a> {
897 #[serde(skip_serializing_if = "std::option::Option::is_none")]
899 pub hide_badges: std::option::Option<bool>,
900}
901
902impl jacquard_common::IntoStatic for VerificationPrefs<'_> {
903 type Output = VerificationPrefs<'static>;
904 fn into_static(self) -> Self::Output {
905 VerificationPrefs {
906 hide_badges: self.hide_badges.into_static(),
907 extra_data: self.extra_data.into_static(),
908 }
909 }
910}
911
912#[jacquard_derive::lexicon]
914#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
915#[serde(rename_all = "camelCase")]
916pub struct VerificationState<'a> {
917 #[serde(borrow)]
919 pub trusted_verifier_status: jacquard_common::CowStr<'a>,
920 #[serde(borrow)]
922 pub verifications: Vec<crate::app_bsky::actor::VerificationView<'a>>,
923 #[serde(borrow)]
925 pub verified_status: jacquard_common::CowStr<'a>,
926}
927
928impl jacquard_common::IntoStatic for VerificationState<'_> {
929 type Output = VerificationState<'static>;
930 fn into_static(self) -> Self::Output {
931 VerificationState {
932 trusted_verifier_status: self.trusted_verifier_status.into_static(),
933 verifications: self.verifications.into_static(),
934 verified_status: self.verified_status.into_static(),
935 extra_data: self.extra_data.into_static(),
936 }
937 }
938}
939
940#[jacquard_derive::lexicon]
942#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
943#[serde(rename_all = "camelCase")]
944pub struct VerificationView<'a> {
945 pub created_at: jacquard_common::types::string::Datetime,
947 pub is_valid: bool,
949 #[serde(borrow)]
951 pub issuer: jacquard_common::types::string::Did<'a>,
952 #[serde(borrow)]
954 pub uri: jacquard_common::types::string::AtUri<'a>,
955}
956
957impl jacquard_common::IntoStatic for VerificationView<'_> {
958 type Output = VerificationView<'static>;
959 fn into_static(self) -> Self::Output {
960 VerificationView {
961 created_at: self.created_at.into_static(),
962 is_valid: self.is_valid.into_static(),
963 issuer: self.issuer.into_static(),
964 uri: self.uri.into_static(),
965 extra_data: self.extra_data.into_static(),
966 }
967 }
968}
969
970#[jacquard_derive::lexicon]
972#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
973#[serde(rename_all = "camelCase")]
974pub struct ViewerState<'a> {
975 #[serde(skip_serializing_if = "std::option::Option::is_none")]
977 #[serde(borrow)]
978 pub activity_subscription: std::option::Option<
979 crate::app_bsky::notification::ActivitySubscription<'a>,
980 >,
981 #[serde(skip_serializing_if = "std::option::Option::is_none")]
982 pub blocked_by: std::option::Option<bool>,
983 #[serde(skip_serializing_if = "std::option::Option::is_none")]
984 #[serde(borrow)]
985 pub blocking: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
986 #[serde(skip_serializing_if = "std::option::Option::is_none")]
987 #[serde(borrow)]
988 pub blocking_by_list: std::option::Option<crate::app_bsky::graph::ListViewBasic<'a>>,
989 #[serde(skip_serializing_if = "std::option::Option::is_none")]
990 #[serde(borrow)]
991 pub followed_by: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
992 #[serde(skip_serializing_if = "std::option::Option::is_none")]
993 #[serde(borrow)]
994 pub following: std::option::Option<jacquard_common::types::string::AtUri<'a>>,
995 #[serde(skip_serializing_if = "std::option::Option::is_none")]
997 #[serde(borrow)]
998 pub known_followers: std::option::Option<crate::app_bsky::actor::KnownFollowers<'a>>,
999 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1000 pub muted: std::option::Option<bool>,
1001 #[serde(skip_serializing_if = "std::option::Option::is_none")]
1002 #[serde(borrow)]
1003 pub muted_by_list: std::option::Option<crate::app_bsky::graph::ListViewBasic<'a>>,
1004}
1005
1006impl jacquard_common::IntoStatic for ViewerState<'_> {
1007 type Output = ViewerState<'static>;
1008 fn into_static(self) -> Self::Output {
1009 ViewerState {
1010 activity_subscription: self.activity_subscription.into_static(),
1011 blocked_by: self.blocked_by.into_static(),
1012 blocking: self.blocking.into_static(),
1013 blocking_by_list: self.blocking_by_list.into_static(),
1014 followed_by: self.followed_by.into_static(),
1015 following: self.following.into_static(),
1016 known_followers: self.known_followers.into_static(),
1017 muted: self.muted.into_static(),
1018 muted_by_list: self.muted_by_list.into_static(),
1019 extra_data: self.extra_data.into_static(),
1020 }
1021 }
1022}