zbrox.com
1// @generated by jacquard-lexicon. DO NOT EDIT.
2//
3// Lexicon: chat.bsky.convo.defs
4//
5// This file was automatically generated from Lexicon schemas.
6// Any manual changes will be overwritten on the next regeneration.
7
8pub mod accept_convo;
9pub mod add_reaction;
10pub mod delete_message_for_self;
11pub mod get_convo;
12pub mod get_convo_availability;
13pub mod get_convo_for_members;
14pub mod get_log;
15pub mod get_messages;
16pub mod leave_convo;
17pub mod list_convos;
18pub mod mute_convo;
19pub mod remove_reaction;
20pub mod send_message;
21pub mod send_message_batch;
22pub mod unmute_convo;
23pub mod update_all_read;
24pub mod update_read;
25
26#[jacquard_derive::lexicon]
27#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
28#[serde(rename_all = "camelCase")]
29pub struct ConvoView<'a> {
30 #[serde(borrow)]
31 pub id: jacquard_common::CowStr<'a>,
32 #[serde(skip_serializing_if = "std::option::Option::is_none")]
33 #[serde(borrow)]
34 pub last_message: std::option::Option<ConvoViewRecordLastMessage<'a>>,
35 #[serde(skip_serializing_if = "std::option::Option::is_none")]
36 #[serde(borrow)]
37 pub last_reaction: std::option::Option<ConvoViewRecordLastReaction<'a>>,
38 #[serde(borrow)]
39 pub members: Vec<crate::chat_bsky::actor::ProfileViewBasic<'a>>,
40 pub muted: bool,
41 #[serde(borrow)]
42 pub rev: jacquard_common::CowStr<'a>,
43 #[serde(skip_serializing_if = "std::option::Option::is_none")]
44 #[serde(borrow)]
45 pub status: std::option::Option<jacquard_common::CowStr<'a>>,
46 pub unread_count: i64,
47}
48
49#[jacquard_derive::open_union]
50#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
51#[serde(tag = "$type")]
52#[serde(bound(deserialize = "'de: 'a"))]
53pub enum ConvoViewRecordLastMessage<'a> {}
54impl jacquard_common::IntoStatic for ConvoViewRecordLastMessage<'_> {
55 type Output = ConvoViewRecordLastMessage<'static>;
56 fn into_static(self) -> Self::Output {
57 match self {
58 ConvoViewRecordLastMessage::Unknown(v) => {
59 ConvoViewRecordLastMessage::Unknown(v.into_static())
60 }
61 }
62 }
63}
64
65#[jacquard_derive::open_union]
66#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
67#[serde(tag = "$type")]
68#[serde(bound(deserialize = "'de: 'a"))]
69pub enum ConvoViewRecordLastReaction<'a> {}
70impl jacquard_common::IntoStatic for ConvoViewRecordLastReaction<'_> {
71 type Output = ConvoViewRecordLastReaction<'static>;
72 fn into_static(self) -> Self::Output {
73 match self {
74 ConvoViewRecordLastReaction::Unknown(v) => {
75 ConvoViewRecordLastReaction::Unknown(v.into_static())
76 }
77 }
78 }
79}
80
81impl jacquard_common::IntoStatic for ConvoView<'_> {
82 type Output = ConvoView<'static>;
83 fn into_static(self) -> Self::Output {
84 ConvoView {
85 id: self.id.into_static(),
86 last_message: self.last_message.into_static(),
87 last_reaction: self.last_reaction.into_static(),
88 members: self.members.into_static(),
89 muted: self.muted.into_static(),
90 rev: self.rev.into_static(),
91 status: self.status.into_static(),
92 unread_count: self.unread_count.into_static(),
93 extra_data: self.extra_data.into_static(),
94 }
95 }
96}
97
98#[jacquard_derive::lexicon]
99#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
100#[serde(rename_all = "camelCase")]
101pub struct DeletedMessageView<'a> {
102 #[serde(borrow)]
103 pub id: jacquard_common::CowStr<'a>,
104 #[serde(borrow)]
105 pub rev: jacquard_common::CowStr<'a>,
106 #[serde(borrow)]
107 pub sender: crate::chat_bsky::convo::MessageViewSender<'a>,
108 pub sent_at: jacquard_common::types::string::Datetime,
109}
110
111impl jacquard_common::IntoStatic for DeletedMessageView<'_> {
112 type Output = DeletedMessageView<'static>;
113 fn into_static(self) -> Self::Output {
114 DeletedMessageView {
115 id: self.id.into_static(),
116 rev: self.rev.into_static(),
117 sender: self.sender.into_static(),
118 sent_at: self.sent_at.into_static(),
119 extra_data: self.extra_data.into_static(),
120 }
121 }
122}
123
124#[jacquard_derive::lexicon]
125#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
126#[serde(rename_all = "camelCase")]
127pub struct LogAcceptConvo<'a> {
128 #[serde(borrow)]
129 pub convo_id: jacquard_common::CowStr<'a>,
130 #[serde(borrow)]
131 pub rev: jacquard_common::CowStr<'a>,
132}
133
134impl jacquard_common::IntoStatic for LogAcceptConvo<'_> {
135 type Output = LogAcceptConvo<'static>;
136 fn into_static(self) -> Self::Output {
137 LogAcceptConvo {
138 convo_id: self.convo_id.into_static(),
139 rev: self.rev.into_static(),
140 extra_data: self.extra_data.into_static(),
141 }
142 }
143}
144
145#[jacquard_derive::lexicon]
146#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
147#[serde(rename_all = "camelCase")]
148pub struct LogAddReaction<'a> {
149 #[serde(borrow)]
150 pub convo_id: jacquard_common::CowStr<'a>,
151 #[serde(borrow)]
152 pub message: LogAddReactionRecordMessage<'a>,
153 #[serde(borrow)]
154 pub reaction: crate::chat_bsky::convo::ReactionView<'a>,
155 #[serde(borrow)]
156 pub rev: jacquard_common::CowStr<'a>,
157}
158
159#[jacquard_derive::open_union]
160#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
161#[serde(tag = "$type")]
162#[serde(bound(deserialize = "'de: 'a"))]
163pub enum LogAddReactionRecordMessage<'a> {}
164impl jacquard_common::IntoStatic for LogAddReactionRecordMessage<'_> {
165 type Output = LogAddReactionRecordMessage<'static>;
166 fn into_static(self) -> Self::Output {
167 match self {
168 LogAddReactionRecordMessage::Unknown(v) => {
169 LogAddReactionRecordMessage::Unknown(v.into_static())
170 }
171 }
172 }
173}
174
175impl jacquard_common::IntoStatic for LogAddReaction<'_> {
176 type Output = LogAddReaction<'static>;
177 fn into_static(self) -> Self::Output {
178 LogAddReaction {
179 convo_id: self.convo_id.into_static(),
180 message: self.message.into_static(),
181 reaction: self.reaction.into_static(),
182 rev: self.rev.into_static(),
183 extra_data: self.extra_data.into_static(),
184 }
185 }
186}
187
188#[jacquard_derive::lexicon]
189#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
190#[serde(rename_all = "camelCase")]
191pub struct LogBeginConvo<'a> {
192 #[serde(borrow)]
193 pub convo_id: jacquard_common::CowStr<'a>,
194 #[serde(borrow)]
195 pub rev: jacquard_common::CowStr<'a>,
196}
197
198impl jacquard_common::IntoStatic for LogBeginConvo<'_> {
199 type Output = LogBeginConvo<'static>;
200 fn into_static(self) -> Self::Output {
201 LogBeginConvo {
202 convo_id: self.convo_id.into_static(),
203 rev: self.rev.into_static(),
204 extra_data: self.extra_data.into_static(),
205 }
206 }
207}
208
209#[jacquard_derive::lexicon]
210#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
211#[serde(rename_all = "camelCase")]
212pub struct LogCreateMessage<'a> {
213 #[serde(borrow)]
214 pub convo_id: jacquard_common::CowStr<'a>,
215 #[serde(borrow)]
216 pub message: LogCreateMessageRecordMessage<'a>,
217 #[serde(borrow)]
218 pub rev: jacquard_common::CowStr<'a>,
219}
220
221#[jacquard_derive::open_union]
222#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
223#[serde(tag = "$type")]
224#[serde(bound(deserialize = "'de: 'a"))]
225pub enum LogCreateMessageRecordMessage<'a> {}
226impl jacquard_common::IntoStatic for LogCreateMessageRecordMessage<'_> {
227 type Output = LogCreateMessageRecordMessage<'static>;
228 fn into_static(self) -> Self::Output {
229 match self {
230 LogCreateMessageRecordMessage::Unknown(v) => {
231 LogCreateMessageRecordMessage::Unknown(v.into_static())
232 }
233 }
234 }
235}
236
237impl jacquard_common::IntoStatic for LogCreateMessage<'_> {
238 type Output = LogCreateMessage<'static>;
239 fn into_static(self) -> Self::Output {
240 LogCreateMessage {
241 convo_id: self.convo_id.into_static(),
242 message: self.message.into_static(),
243 rev: self.rev.into_static(),
244 extra_data: self.extra_data.into_static(),
245 }
246 }
247}
248
249#[jacquard_derive::lexicon]
250#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
251#[serde(rename_all = "camelCase")]
252pub struct LogDeleteMessage<'a> {
253 #[serde(borrow)]
254 pub convo_id: jacquard_common::CowStr<'a>,
255 #[serde(borrow)]
256 pub message: LogDeleteMessageRecordMessage<'a>,
257 #[serde(borrow)]
258 pub rev: jacquard_common::CowStr<'a>,
259}
260
261#[jacquard_derive::open_union]
262#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
263#[serde(tag = "$type")]
264#[serde(bound(deserialize = "'de: 'a"))]
265pub enum LogDeleteMessageRecordMessage<'a> {}
266impl jacquard_common::IntoStatic for LogDeleteMessageRecordMessage<'_> {
267 type Output = LogDeleteMessageRecordMessage<'static>;
268 fn into_static(self) -> Self::Output {
269 match self {
270 LogDeleteMessageRecordMessage::Unknown(v) => {
271 LogDeleteMessageRecordMessage::Unknown(v.into_static())
272 }
273 }
274 }
275}
276
277impl jacquard_common::IntoStatic for LogDeleteMessage<'_> {
278 type Output = LogDeleteMessage<'static>;
279 fn into_static(self) -> Self::Output {
280 LogDeleteMessage {
281 convo_id: self.convo_id.into_static(),
282 message: self.message.into_static(),
283 rev: self.rev.into_static(),
284 extra_data: self.extra_data.into_static(),
285 }
286 }
287}
288
289#[jacquard_derive::lexicon]
290#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
291#[serde(rename_all = "camelCase")]
292pub struct LogLeaveConvo<'a> {
293 #[serde(borrow)]
294 pub convo_id: jacquard_common::CowStr<'a>,
295 #[serde(borrow)]
296 pub rev: jacquard_common::CowStr<'a>,
297}
298
299impl jacquard_common::IntoStatic for LogLeaveConvo<'_> {
300 type Output = LogLeaveConvo<'static>;
301 fn into_static(self) -> Self::Output {
302 LogLeaveConvo {
303 convo_id: self.convo_id.into_static(),
304 rev: self.rev.into_static(),
305 extra_data: self.extra_data.into_static(),
306 }
307 }
308}
309
310#[jacquard_derive::lexicon]
311#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
312#[serde(rename_all = "camelCase")]
313pub struct LogMuteConvo<'a> {
314 #[serde(borrow)]
315 pub convo_id: jacquard_common::CowStr<'a>,
316 #[serde(borrow)]
317 pub rev: jacquard_common::CowStr<'a>,
318}
319
320impl jacquard_common::IntoStatic for LogMuteConvo<'_> {
321 type Output = LogMuteConvo<'static>;
322 fn into_static(self) -> Self::Output {
323 LogMuteConvo {
324 convo_id: self.convo_id.into_static(),
325 rev: self.rev.into_static(),
326 extra_data: self.extra_data.into_static(),
327 }
328 }
329}
330
331#[jacquard_derive::lexicon]
332#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
333#[serde(rename_all = "camelCase")]
334pub struct LogReadMessage<'a> {
335 #[serde(borrow)]
336 pub convo_id: jacquard_common::CowStr<'a>,
337 #[serde(borrow)]
338 pub message: LogReadMessageRecordMessage<'a>,
339 #[serde(borrow)]
340 pub rev: jacquard_common::CowStr<'a>,
341}
342
343#[jacquard_derive::open_union]
344#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
345#[serde(tag = "$type")]
346#[serde(bound(deserialize = "'de: 'a"))]
347pub enum LogReadMessageRecordMessage<'a> {}
348impl jacquard_common::IntoStatic for LogReadMessageRecordMessage<'_> {
349 type Output = LogReadMessageRecordMessage<'static>;
350 fn into_static(self) -> Self::Output {
351 match self {
352 LogReadMessageRecordMessage::Unknown(v) => {
353 LogReadMessageRecordMessage::Unknown(v.into_static())
354 }
355 }
356 }
357}
358
359impl jacquard_common::IntoStatic for LogReadMessage<'_> {
360 type Output = LogReadMessage<'static>;
361 fn into_static(self) -> Self::Output {
362 LogReadMessage {
363 convo_id: self.convo_id.into_static(),
364 message: self.message.into_static(),
365 rev: self.rev.into_static(),
366 extra_data: self.extra_data.into_static(),
367 }
368 }
369}
370
371#[jacquard_derive::lexicon]
372#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
373#[serde(rename_all = "camelCase")]
374pub struct LogRemoveReaction<'a> {
375 #[serde(borrow)]
376 pub convo_id: jacquard_common::CowStr<'a>,
377 #[serde(borrow)]
378 pub message: LogRemoveReactionRecordMessage<'a>,
379 #[serde(borrow)]
380 pub reaction: crate::chat_bsky::convo::ReactionView<'a>,
381 #[serde(borrow)]
382 pub rev: jacquard_common::CowStr<'a>,
383}
384
385#[jacquard_derive::open_union]
386#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
387#[serde(tag = "$type")]
388#[serde(bound(deserialize = "'de: 'a"))]
389pub enum LogRemoveReactionRecordMessage<'a> {}
390impl jacquard_common::IntoStatic for LogRemoveReactionRecordMessage<'_> {
391 type Output = LogRemoveReactionRecordMessage<'static>;
392 fn into_static(self) -> Self::Output {
393 match self {
394 LogRemoveReactionRecordMessage::Unknown(v) => {
395 LogRemoveReactionRecordMessage::Unknown(v.into_static())
396 }
397 }
398 }
399}
400
401impl jacquard_common::IntoStatic for LogRemoveReaction<'_> {
402 type Output = LogRemoveReaction<'static>;
403 fn into_static(self) -> Self::Output {
404 LogRemoveReaction {
405 convo_id: self.convo_id.into_static(),
406 message: self.message.into_static(),
407 reaction: self.reaction.into_static(),
408 rev: self.rev.into_static(),
409 extra_data: self.extra_data.into_static(),
410 }
411 }
412}
413
414#[jacquard_derive::lexicon]
415#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
416#[serde(rename_all = "camelCase")]
417pub struct LogUnmuteConvo<'a> {
418 #[serde(borrow)]
419 pub convo_id: jacquard_common::CowStr<'a>,
420 #[serde(borrow)]
421 pub rev: jacquard_common::CowStr<'a>,
422}
423
424impl jacquard_common::IntoStatic for LogUnmuteConvo<'_> {
425 type Output = LogUnmuteConvo<'static>;
426 fn into_static(self) -> Self::Output {
427 LogUnmuteConvo {
428 convo_id: self.convo_id.into_static(),
429 rev: self.rev.into_static(),
430 extra_data: self.extra_data.into_static(),
431 }
432 }
433}
434
435#[jacquard_derive::lexicon]
436#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
437#[serde(rename_all = "camelCase")]
438pub struct MessageAndReactionView<'a> {
439 #[serde(borrow)]
440 pub message: crate::chat_bsky::convo::MessageView<'a>,
441 #[serde(borrow)]
442 pub reaction: crate::chat_bsky::convo::ReactionView<'a>,
443}
444
445impl jacquard_common::IntoStatic for MessageAndReactionView<'_> {
446 type Output = MessageAndReactionView<'static>;
447 fn into_static(self) -> Self::Output {
448 MessageAndReactionView {
449 message: self.message.into_static(),
450 reaction: self.reaction.into_static(),
451 extra_data: self.extra_data.into_static(),
452 }
453 }
454}
455
456#[jacquard_derive::lexicon]
457#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
458#[serde(rename_all = "camelCase")]
459pub struct MessageInput<'a> {
460 #[serde(skip_serializing_if = "std::option::Option::is_none")]
461 #[serde(borrow)]
462 pub embed: std::option::Option<MessageInputRecordEmbed<'a>>,
463 ///Annotations of text (mentions, URLs, hashtags, etc)
464 #[serde(skip_serializing_if = "std::option::Option::is_none")]
465 #[serde(borrow)]
466 pub facets: std::option::Option<Vec<crate::app_bsky::richtext::facet::Facet<'a>>>,
467 #[serde(borrow)]
468 pub text: jacquard_common::CowStr<'a>,
469}
470
471#[jacquard_derive::open_union]
472#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
473#[serde(tag = "$type")]
474#[serde(bound(deserialize = "'de: 'a"))]
475pub enum MessageInputRecordEmbed<'a> {
476 #[serde(rename = "app.bsky.embed.record")]
477 Record(Box<crate::app_bsky::embed::record::Record<'a>>),
478}
479
480impl jacquard_common::IntoStatic for MessageInputRecordEmbed<'_> {
481 type Output = MessageInputRecordEmbed<'static>;
482 fn into_static(self) -> Self::Output {
483 match self {
484 MessageInputRecordEmbed::Record(v) => {
485 MessageInputRecordEmbed::Record(v.into_static())
486 }
487 MessageInputRecordEmbed::Unknown(v) => {
488 MessageInputRecordEmbed::Unknown(v.into_static())
489 }
490 }
491 }
492}
493
494impl jacquard_common::IntoStatic for MessageInput<'_> {
495 type Output = MessageInput<'static>;
496 fn into_static(self) -> Self::Output {
497 MessageInput {
498 embed: self.embed.into_static(),
499 facets: self.facets.into_static(),
500 text: self.text.into_static(),
501 extra_data: self.extra_data.into_static(),
502 }
503 }
504}
505
506#[jacquard_derive::lexicon]
507#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
508#[serde(rename_all = "camelCase")]
509pub struct MessageRef<'a> {
510 #[serde(borrow)]
511 pub convo_id: jacquard_common::CowStr<'a>,
512 #[serde(borrow)]
513 pub did: jacquard_common::types::string::Did<'a>,
514 #[serde(borrow)]
515 pub message_id: jacquard_common::CowStr<'a>,
516}
517
518impl jacquard_common::IntoStatic for MessageRef<'_> {
519 type Output = MessageRef<'static>;
520 fn into_static(self) -> Self::Output {
521 MessageRef {
522 convo_id: self.convo_id.into_static(),
523 did: self.did.into_static(),
524 message_id: self.message_id.into_static(),
525 extra_data: self.extra_data.into_static(),
526 }
527 }
528}
529
530#[jacquard_derive::lexicon]
531#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
532#[serde(rename_all = "camelCase")]
533pub struct MessageView<'a> {
534 #[serde(skip_serializing_if = "std::option::Option::is_none")]
535 #[serde(borrow)]
536 pub embed: std::option::Option<MessageViewRecordEmbed<'a>>,
537 ///Annotations of text (mentions, URLs, hashtags, etc)
538 #[serde(skip_serializing_if = "std::option::Option::is_none")]
539 #[serde(borrow)]
540 pub facets: std::option::Option<Vec<crate::app_bsky::richtext::facet::Facet<'a>>>,
541 #[serde(borrow)]
542 pub id: jacquard_common::CowStr<'a>,
543 ///Reactions to this message, in ascending order of creation time.
544 #[serde(skip_serializing_if = "std::option::Option::is_none")]
545 #[serde(borrow)]
546 pub reactions: std::option::Option<Vec<crate::chat_bsky::convo::ReactionView<'a>>>,
547 #[serde(borrow)]
548 pub rev: jacquard_common::CowStr<'a>,
549 #[serde(borrow)]
550 pub sender: crate::chat_bsky::convo::MessageViewSender<'a>,
551 pub sent_at: jacquard_common::types::string::Datetime,
552 #[serde(borrow)]
553 pub text: jacquard_common::CowStr<'a>,
554}
555
556#[jacquard_derive::open_union]
557#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
558#[serde(tag = "$type")]
559#[serde(bound(deserialize = "'de: 'a"))]
560pub enum MessageViewRecordEmbed<'a> {
561 #[serde(rename = "app.bsky.embed.record#view")]
562 RecordView(Box<crate::app_bsky::embed::record::View<'a>>),
563}
564
565impl jacquard_common::IntoStatic for MessageViewRecordEmbed<'_> {
566 type Output = MessageViewRecordEmbed<'static>;
567 fn into_static(self) -> Self::Output {
568 match self {
569 MessageViewRecordEmbed::RecordView(v) => {
570 MessageViewRecordEmbed::RecordView(v.into_static())
571 }
572 MessageViewRecordEmbed::Unknown(v) => {
573 MessageViewRecordEmbed::Unknown(v.into_static())
574 }
575 }
576 }
577}
578
579impl jacquard_common::IntoStatic for MessageView<'_> {
580 type Output = MessageView<'static>;
581 fn into_static(self) -> Self::Output {
582 MessageView {
583 embed: self.embed.into_static(),
584 facets: self.facets.into_static(),
585 id: self.id.into_static(),
586 reactions: self.reactions.into_static(),
587 rev: self.rev.into_static(),
588 sender: self.sender.into_static(),
589 sent_at: self.sent_at.into_static(),
590 text: self.text.into_static(),
591 extra_data: self.extra_data.into_static(),
592 }
593 }
594}
595
596#[jacquard_derive::lexicon]
597#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
598#[serde(rename_all = "camelCase")]
599pub struct MessageViewSender<'a> {
600 #[serde(borrow)]
601 pub did: jacquard_common::types::string::Did<'a>,
602}
603
604impl jacquard_common::IntoStatic for MessageViewSender<'_> {
605 type Output = MessageViewSender<'static>;
606 fn into_static(self) -> Self::Output {
607 MessageViewSender {
608 did: self.did.into_static(),
609 extra_data: self.extra_data.into_static(),
610 }
611 }
612}
613
614#[jacquard_derive::lexicon]
615#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
616#[serde(rename_all = "camelCase")]
617pub struct ReactionView<'a> {
618 pub created_at: jacquard_common::types::string::Datetime,
619 #[serde(borrow)]
620 pub sender: crate::chat_bsky::convo::ReactionViewSender<'a>,
621 #[serde(borrow)]
622 pub value: jacquard_common::CowStr<'a>,
623}
624
625impl jacquard_common::IntoStatic for ReactionView<'_> {
626 type Output = ReactionView<'static>;
627 fn into_static(self) -> Self::Output {
628 ReactionView {
629 created_at: self.created_at.into_static(),
630 sender: self.sender.into_static(),
631 value: self.value.into_static(),
632 extra_data: self.extra_data.into_static(),
633 }
634 }
635}
636
637#[jacquard_derive::lexicon]
638#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
639#[serde(rename_all = "camelCase")]
640pub struct ReactionViewSender<'a> {
641 #[serde(borrow)]
642 pub did: jacquard_common::types::string::Did<'a>,
643}
644
645impl jacquard_common::IntoStatic for ReactionViewSender<'_> {
646 type Output = ReactionViewSender<'static>;
647 fn into_static(self) -> Self::Output {
648 ReactionViewSender {
649 did: self.did.into_static(),
650 extra_data: self.extra_data.into_static(),
651 }
652 }
653}