jacquard_api/chat_bsky/
convo.rs

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
27#[allow(unused_imports)]
28use alloc::collections::BTreeMap;
29
30#[allow(unused_imports)]
31use core::marker::PhantomData;
32use jacquard_common::CowStr;
33
34#[allow(unused_imports)]
35use jacquard_common::deps::codegen::unicode_segmentation::UnicodeSegmentation;
36use jacquard_common::types::string::{Did, Datetime};
37use jacquard_derive::{IntoStatic, lexicon, open_union};
38use jacquard_lexicon::lexicon::LexiconDoc;
39use jacquard_lexicon::schema::LexiconSchema;
40
41#[allow(unused_imports)]
42use jacquard_lexicon::validation::{ConstraintError, ValidationPath};
43use serde::{Serialize, Deserialize};
44use crate::app_bsky::embed::record::Record;
45use crate::app_bsky::embed::record::View;
46use crate::app_bsky::richtext::facet::Facet;
47use crate::chat_bsky::actor::ProfileViewBasic;
48use crate::chat_bsky::convo;
49
50#[lexicon]
51#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
52#[serde(rename_all = "camelCase")]
53pub struct ConvoView<'a> {
54    #[serde(borrow)]
55    pub id: CowStr<'a>,
56    #[serde(skip_serializing_if = "Option::is_none")]
57    #[serde(borrow)]
58    pub last_message: Option<ConvoViewLastMessage<'a>>,
59    #[serde(skip_serializing_if = "Option::is_none")]
60    #[serde(borrow)]
61    pub last_reaction: Option<convo::MessageAndReactionView<'a>>,
62    #[serde(borrow)]
63    pub members: Vec<ProfileViewBasic<'a>>,
64    pub muted: bool,
65    #[serde(borrow)]
66    pub rev: CowStr<'a>,
67    #[serde(skip_serializing_if = "Option::is_none")]
68    #[serde(borrow)]
69    pub status: Option<ConvoViewStatus<'a>>,
70    pub unread_count: i64,
71}
72
73
74#[open_union]
75#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
76#[serde(tag = "$type", bound(deserialize = "'de: 'a"))]
77pub enum ConvoViewLastMessage<'a> {
78    #[serde(rename = "chat.bsky.convo.defs#messageView")]
79    MessageView(Box<convo::MessageView<'a>>),
80    #[serde(rename = "chat.bsky.convo.defs#deletedMessageView")]
81    DeletedMessageView(Box<convo::DeletedMessageView<'a>>),
82}
83
84
85#[derive(Debug, Clone, PartialEq, Eq, Hash)]
86pub enum ConvoViewStatus<'a> {
87    Request,
88    Accepted,
89    Other(CowStr<'a>),
90}
91
92impl<'a> ConvoViewStatus<'a> {
93    pub fn as_str(&self) -> &str {
94        match self {
95            Self::Request => "request",
96            Self::Accepted => "accepted",
97            Self::Other(s) => s.as_ref(),
98        }
99    }
100}
101
102impl<'a> From<&'a str> for ConvoViewStatus<'a> {
103    fn from(s: &'a str) -> Self {
104        match s {
105            "request" => Self::Request,
106            "accepted" => Self::Accepted,
107            _ => Self::Other(CowStr::from(s)),
108        }
109    }
110}
111
112impl<'a> From<String> for ConvoViewStatus<'a> {
113    fn from(s: String) -> Self {
114        match s.as_str() {
115            "request" => Self::Request,
116            "accepted" => Self::Accepted,
117            _ => Self::Other(CowStr::from(s)),
118        }
119    }
120}
121
122impl<'a> core::fmt::Display for ConvoViewStatus<'a> {
123    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
124        write!(f, "{}", self.as_str())
125    }
126}
127
128impl<'a> AsRef<str> for ConvoViewStatus<'a> {
129    fn as_ref(&self) -> &str {
130        self.as_str()
131    }
132}
133
134impl<'a> serde::Serialize for ConvoViewStatus<'a> {
135    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
136    where
137        S: serde::Serializer,
138    {
139        serializer.serialize_str(self.as_str())
140    }
141}
142
143impl<'de, 'a> serde::Deserialize<'de> for ConvoViewStatus<'a>
144where
145    'de: 'a,
146{
147    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
148    where
149        D: serde::Deserializer<'de>,
150    {
151        let s = <&'de str>::deserialize(deserializer)?;
152        Ok(Self::from(s))
153    }
154}
155
156impl<'a> Default for ConvoViewStatus<'a> {
157    fn default() -> Self {
158        Self::Other(Default::default())
159    }
160}
161
162impl jacquard_common::IntoStatic for ConvoViewStatus<'_> {
163    type Output = ConvoViewStatus<'static>;
164    fn into_static(self) -> Self::Output {
165        match self {
166            ConvoViewStatus::Request => ConvoViewStatus::Request,
167            ConvoViewStatus::Accepted => ConvoViewStatus::Accepted,
168            ConvoViewStatus::Other(v) => ConvoViewStatus::Other(v.into_static()),
169        }
170    }
171}
172
173
174#[lexicon]
175#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
176#[serde(rename_all = "camelCase")]
177pub struct DeletedMessageView<'a> {
178    #[serde(borrow)]
179    pub id: CowStr<'a>,
180    #[serde(borrow)]
181    pub rev: CowStr<'a>,
182    #[serde(borrow)]
183    pub sender: convo::MessageViewSender<'a>,
184    pub sent_at: Datetime,
185}
186
187
188#[lexicon]
189#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
190#[serde(rename_all = "camelCase")]
191pub struct LogAcceptConvo<'a> {
192    #[serde(borrow)]
193    pub convo_id: CowStr<'a>,
194    #[serde(borrow)]
195    pub rev: CowStr<'a>,
196}
197
198
199#[lexicon]
200#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
201#[serde(rename_all = "camelCase")]
202pub struct LogAddReaction<'a> {
203    #[serde(borrow)]
204    pub convo_id: CowStr<'a>,
205    #[serde(borrow)]
206    pub message: LogAddReactionMessage<'a>,
207    #[serde(borrow)]
208    pub reaction: convo::ReactionView<'a>,
209    #[serde(borrow)]
210    pub rev: CowStr<'a>,
211}
212
213
214#[open_union]
215#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
216#[serde(tag = "$type", bound(deserialize = "'de: 'a"))]
217pub enum LogAddReactionMessage<'a> {
218    #[serde(rename = "chat.bsky.convo.defs#messageView")]
219    MessageView(Box<convo::MessageView<'a>>),
220    #[serde(rename = "chat.bsky.convo.defs#deletedMessageView")]
221    DeletedMessageView(Box<convo::DeletedMessageView<'a>>),
222}
223
224
225#[lexicon]
226#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
227#[serde(rename_all = "camelCase")]
228pub struct LogBeginConvo<'a> {
229    #[serde(borrow)]
230    pub convo_id: CowStr<'a>,
231    #[serde(borrow)]
232    pub rev: CowStr<'a>,
233}
234
235
236#[lexicon]
237#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
238#[serde(rename_all = "camelCase")]
239pub struct LogCreateMessage<'a> {
240    #[serde(borrow)]
241    pub convo_id: CowStr<'a>,
242    #[serde(borrow)]
243    pub message: LogCreateMessageMessage<'a>,
244    #[serde(borrow)]
245    pub rev: CowStr<'a>,
246}
247
248
249#[open_union]
250#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
251#[serde(tag = "$type", bound(deserialize = "'de: 'a"))]
252pub enum LogCreateMessageMessage<'a> {
253    #[serde(rename = "chat.bsky.convo.defs#messageView")]
254    MessageView(Box<convo::MessageView<'a>>),
255    #[serde(rename = "chat.bsky.convo.defs#deletedMessageView")]
256    DeletedMessageView(Box<convo::DeletedMessageView<'a>>),
257}
258
259
260#[lexicon]
261#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
262#[serde(rename_all = "camelCase")]
263pub struct LogDeleteMessage<'a> {
264    #[serde(borrow)]
265    pub convo_id: CowStr<'a>,
266    #[serde(borrow)]
267    pub message: LogDeleteMessageMessage<'a>,
268    #[serde(borrow)]
269    pub rev: CowStr<'a>,
270}
271
272
273#[open_union]
274#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
275#[serde(tag = "$type", bound(deserialize = "'de: 'a"))]
276pub enum LogDeleteMessageMessage<'a> {
277    #[serde(rename = "chat.bsky.convo.defs#messageView")]
278    MessageView(Box<convo::MessageView<'a>>),
279    #[serde(rename = "chat.bsky.convo.defs#deletedMessageView")]
280    DeletedMessageView(Box<convo::DeletedMessageView<'a>>),
281}
282
283
284#[lexicon]
285#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
286#[serde(rename_all = "camelCase")]
287pub struct LogLeaveConvo<'a> {
288    #[serde(borrow)]
289    pub convo_id: CowStr<'a>,
290    #[serde(borrow)]
291    pub rev: CowStr<'a>,
292}
293
294
295#[lexicon]
296#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
297#[serde(rename_all = "camelCase")]
298pub struct LogMuteConvo<'a> {
299    #[serde(borrow)]
300    pub convo_id: CowStr<'a>,
301    #[serde(borrow)]
302    pub rev: CowStr<'a>,
303}
304
305
306#[lexicon]
307#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
308#[serde(rename_all = "camelCase")]
309pub struct LogReadMessage<'a> {
310    #[serde(borrow)]
311    pub convo_id: CowStr<'a>,
312    #[serde(borrow)]
313    pub message: LogReadMessageMessage<'a>,
314    #[serde(borrow)]
315    pub rev: CowStr<'a>,
316}
317
318
319#[open_union]
320#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
321#[serde(tag = "$type", bound(deserialize = "'de: 'a"))]
322pub enum LogReadMessageMessage<'a> {
323    #[serde(rename = "chat.bsky.convo.defs#messageView")]
324    MessageView(Box<convo::MessageView<'a>>),
325    #[serde(rename = "chat.bsky.convo.defs#deletedMessageView")]
326    DeletedMessageView(Box<convo::DeletedMessageView<'a>>),
327}
328
329
330#[lexicon]
331#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
332#[serde(rename_all = "camelCase")]
333pub struct LogRemoveReaction<'a> {
334    #[serde(borrow)]
335    pub convo_id: CowStr<'a>,
336    #[serde(borrow)]
337    pub message: LogRemoveReactionMessage<'a>,
338    #[serde(borrow)]
339    pub reaction: convo::ReactionView<'a>,
340    #[serde(borrow)]
341    pub rev: CowStr<'a>,
342}
343
344
345#[open_union]
346#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
347#[serde(tag = "$type", bound(deserialize = "'de: 'a"))]
348pub enum LogRemoveReactionMessage<'a> {
349    #[serde(rename = "chat.bsky.convo.defs#messageView")]
350    MessageView(Box<convo::MessageView<'a>>),
351    #[serde(rename = "chat.bsky.convo.defs#deletedMessageView")]
352    DeletedMessageView(Box<convo::DeletedMessageView<'a>>),
353}
354
355
356#[lexicon]
357#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
358#[serde(rename_all = "camelCase")]
359pub struct LogUnmuteConvo<'a> {
360    #[serde(borrow)]
361    pub convo_id: CowStr<'a>,
362    #[serde(borrow)]
363    pub rev: CowStr<'a>,
364}
365
366
367#[lexicon]
368#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
369#[serde(rename_all = "camelCase")]
370pub struct MessageAndReactionView<'a> {
371    #[serde(borrow)]
372    pub message: convo::MessageView<'a>,
373    #[serde(borrow)]
374    pub reaction: convo::ReactionView<'a>,
375}
376
377
378#[lexicon]
379#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
380#[serde(rename_all = "camelCase")]
381pub struct MessageInput<'a> {
382    #[serde(skip_serializing_if = "Option::is_none")]
383    #[serde(borrow)]
384    pub embed: Option<Record<'a>>,
385    ///Annotations of text (mentions, URLs, hashtags, etc)
386    #[serde(skip_serializing_if = "Option::is_none")]
387    #[serde(borrow)]
388    pub facets: Option<Vec<Facet<'a>>>,
389    #[serde(borrow)]
390    pub text: CowStr<'a>,
391}
392
393
394#[lexicon]
395#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
396#[serde(rename_all = "camelCase")]
397pub struct MessageRef<'a> {
398    #[serde(borrow)]
399    pub convo_id: CowStr<'a>,
400    #[serde(borrow)]
401    pub did: Did<'a>,
402    #[serde(borrow)]
403    pub message_id: CowStr<'a>,
404}
405
406
407#[lexicon]
408#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
409#[serde(rename_all = "camelCase")]
410pub struct MessageView<'a> {
411    #[serde(skip_serializing_if = "Option::is_none")]
412    #[serde(borrow)]
413    pub embed: Option<View<'a>>,
414    ///Annotations of text (mentions, URLs, hashtags, etc)
415    #[serde(skip_serializing_if = "Option::is_none")]
416    #[serde(borrow)]
417    pub facets: Option<Vec<Facet<'a>>>,
418    #[serde(borrow)]
419    pub id: CowStr<'a>,
420    ///Reactions to this message, in ascending order of creation time.
421    #[serde(skip_serializing_if = "Option::is_none")]
422    #[serde(borrow)]
423    pub reactions: Option<Vec<convo::ReactionView<'a>>>,
424    #[serde(borrow)]
425    pub rev: CowStr<'a>,
426    #[serde(borrow)]
427    pub sender: convo::MessageViewSender<'a>,
428    pub sent_at: Datetime,
429    #[serde(borrow)]
430    pub text: CowStr<'a>,
431}
432
433
434#[lexicon]
435#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
436#[serde(rename_all = "camelCase")]
437pub struct MessageViewSender<'a> {
438    #[serde(borrow)]
439    pub did: Did<'a>,
440}
441
442
443#[lexicon]
444#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
445#[serde(rename_all = "camelCase")]
446pub struct ReactionView<'a> {
447    pub created_at: Datetime,
448    #[serde(borrow)]
449    pub sender: convo::ReactionViewSender<'a>,
450    #[serde(borrow)]
451    pub value: CowStr<'a>,
452}
453
454
455#[lexicon]
456#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
457#[serde(rename_all = "camelCase")]
458pub struct ReactionViewSender<'a> {
459    #[serde(borrow)]
460    pub did: Did<'a>,
461}
462
463impl<'a> LexiconSchema for ConvoView<'a> {
464    fn nsid() -> &'static str {
465        "chat.bsky.convo.defs"
466    }
467    fn def_name() -> &'static str {
468        "convoView"
469    }
470    fn lexicon_doc() -> LexiconDoc<'static> {
471        lexicon_doc_chat_bsky_convo_defs()
472    }
473    fn validate(&self) -> Result<(), ConstraintError> {
474        Ok(())
475    }
476}
477
478impl<'a> LexiconSchema for DeletedMessageView<'a> {
479    fn nsid() -> &'static str {
480        "chat.bsky.convo.defs"
481    }
482    fn def_name() -> &'static str {
483        "deletedMessageView"
484    }
485    fn lexicon_doc() -> LexiconDoc<'static> {
486        lexicon_doc_chat_bsky_convo_defs()
487    }
488    fn validate(&self) -> Result<(), ConstraintError> {
489        Ok(())
490    }
491}
492
493impl<'a> LexiconSchema for LogAcceptConvo<'a> {
494    fn nsid() -> &'static str {
495        "chat.bsky.convo.defs"
496    }
497    fn def_name() -> &'static str {
498        "logAcceptConvo"
499    }
500    fn lexicon_doc() -> LexiconDoc<'static> {
501        lexicon_doc_chat_bsky_convo_defs()
502    }
503    fn validate(&self) -> Result<(), ConstraintError> {
504        Ok(())
505    }
506}
507
508impl<'a> LexiconSchema for LogAddReaction<'a> {
509    fn nsid() -> &'static str {
510        "chat.bsky.convo.defs"
511    }
512    fn def_name() -> &'static str {
513        "logAddReaction"
514    }
515    fn lexicon_doc() -> LexiconDoc<'static> {
516        lexicon_doc_chat_bsky_convo_defs()
517    }
518    fn validate(&self) -> Result<(), ConstraintError> {
519        Ok(())
520    }
521}
522
523impl<'a> LexiconSchema for LogBeginConvo<'a> {
524    fn nsid() -> &'static str {
525        "chat.bsky.convo.defs"
526    }
527    fn def_name() -> &'static str {
528        "logBeginConvo"
529    }
530    fn lexicon_doc() -> LexiconDoc<'static> {
531        lexicon_doc_chat_bsky_convo_defs()
532    }
533    fn validate(&self) -> Result<(), ConstraintError> {
534        Ok(())
535    }
536}
537
538impl<'a> LexiconSchema for LogCreateMessage<'a> {
539    fn nsid() -> &'static str {
540        "chat.bsky.convo.defs"
541    }
542    fn def_name() -> &'static str {
543        "logCreateMessage"
544    }
545    fn lexicon_doc() -> LexiconDoc<'static> {
546        lexicon_doc_chat_bsky_convo_defs()
547    }
548    fn validate(&self) -> Result<(), ConstraintError> {
549        Ok(())
550    }
551}
552
553impl<'a> LexiconSchema for LogDeleteMessage<'a> {
554    fn nsid() -> &'static str {
555        "chat.bsky.convo.defs"
556    }
557    fn def_name() -> &'static str {
558        "logDeleteMessage"
559    }
560    fn lexicon_doc() -> LexiconDoc<'static> {
561        lexicon_doc_chat_bsky_convo_defs()
562    }
563    fn validate(&self) -> Result<(), ConstraintError> {
564        Ok(())
565    }
566}
567
568impl<'a> LexiconSchema for LogLeaveConvo<'a> {
569    fn nsid() -> &'static str {
570        "chat.bsky.convo.defs"
571    }
572    fn def_name() -> &'static str {
573        "logLeaveConvo"
574    }
575    fn lexicon_doc() -> LexiconDoc<'static> {
576        lexicon_doc_chat_bsky_convo_defs()
577    }
578    fn validate(&self) -> Result<(), ConstraintError> {
579        Ok(())
580    }
581}
582
583impl<'a> LexiconSchema for LogMuteConvo<'a> {
584    fn nsid() -> &'static str {
585        "chat.bsky.convo.defs"
586    }
587    fn def_name() -> &'static str {
588        "logMuteConvo"
589    }
590    fn lexicon_doc() -> LexiconDoc<'static> {
591        lexicon_doc_chat_bsky_convo_defs()
592    }
593    fn validate(&self) -> Result<(), ConstraintError> {
594        Ok(())
595    }
596}
597
598impl<'a> LexiconSchema for LogReadMessage<'a> {
599    fn nsid() -> &'static str {
600        "chat.bsky.convo.defs"
601    }
602    fn def_name() -> &'static str {
603        "logReadMessage"
604    }
605    fn lexicon_doc() -> LexiconDoc<'static> {
606        lexicon_doc_chat_bsky_convo_defs()
607    }
608    fn validate(&self) -> Result<(), ConstraintError> {
609        Ok(())
610    }
611}
612
613impl<'a> LexiconSchema for LogRemoveReaction<'a> {
614    fn nsid() -> &'static str {
615        "chat.bsky.convo.defs"
616    }
617    fn def_name() -> &'static str {
618        "logRemoveReaction"
619    }
620    fn lexicon_doc() -> LexiconDoc<'static> {
621        lexicon_doc_chat_bsky_convo_defs()
622    }
623    fn validate(&self) -> Result<(), ConstraintError> {
624        Ok(())
625    }
626}
627
628impl<'a> LexiconSchema for LogUnmuteConvo<'a> {
629    fn nsid() -> &'static str {
630        "chat.bsky.convo.defs"
631    }
632    fn def_name() -> &'static str {
633        "logUnmuteConvo"
634    }
635    fn lexicon_doc() -> LexiconDoc<'static> {
636        lexicon_doc_chat_bsky_convo_defs()
637    }
638    fn validate(&self) -> Result<(), ConstraintError> {
639        Ok(())
640    }
641}
642
643impl<'a> LexiconSchema for MessageAndReactionView<'a> {
644    fn nsid() -> &'static str {
645        "chat.bsky.convo.defs"
646    }
647    fn def_name() -> &'static str {
648        "messageAndReactionView"
649    }
650    fn lexicon_doc() -> LexiconDoc<'static> {
651        lexicon_doc_chat_bsky_convo_defs()
652    }
653    fn validate(&self) -> Result<(), ConstraintError> {
654        Ok(())
655    }
656}
657
658impl<'a> LexiconSchema for MessageInput<'a> {
659    fn nsid() -> &'static str {
660        "chat.bsky.convo.defs"
661    }
662    fn def_name() -> &'static str {
663        "messageInput"
664    }
665    fn lexicon_doc() -> LexiconDoc<'static> {
666        lexicon_doc_chat_bsky_convo_defs()
667    }
668    fn validate(&self) -> Result<(), ConstraintError> {
669        {
670            let value = &self.text;
671            #[allow(unused_comparisons)]
672            if <str>::len(value.as_ref()) > 10000usize {
673                return Err(ConstraintError::MaxLength {
674                    path: ValidationPath::from_field("text"),
675                    max: 10000usize,
676                    actual: <str>::len(value.as_ref()),
677                });
678            }
679        }
680        {
681            let value = &self.text;
682            {
683                let count = UnicodeSegmentation::graphemes(value.as_ref(), true).count();
684                if count > 1000usize {
685                    return Err(ConstraintError::MaxGraphemes {
686                        path: ValidationPath::from_field("text"),
687                        max: 1000usize,
688                        actual: count,
689                    });
690                }
691            }
692        }
693        Ok(())
694    }
695}
696
697impl<'a> LexiconSchema for MessageRef<'a> {
698    fn nsid() -> &'static str {
699        "chat.bsky.convo.defs"
700    }
701    fn def_name() -> &'static str {
702        "messageRef"
703    }
704    fn lexicon_doc() -> LexiconDoc<'static> {
705        lexicon_doc_chat_bsky_convo_defs()
706    }
707    fn validate(&self) -> Result<(), ConstraintError> {
708        Ok(())
709    }
710}
711
712impl<'a> LexiconSchema for MessageView<'a> {
713    fn nsid() -> &'static str {
714        "chat.bsky.convo.defs"
715    }
716    fn def_name() -> &'static str {
717        "messageView"
718    }
719    fn lexicon_doc() -> LexiconDoc<'static> {
720        lexicon_doc_chat_bsky_convo_defs()
721    }
722    fn validate(&self) -> Result<(), ConstraintError> {
723        {
724            let value = &self.text;
725            #[allow(unused_comparisons)]
726            if <str>::len(value.as_ref()) > 10000usize {
727                return Err(ConstraintError::MaxLength {
728                    path: ValidationPath::from_field("text"),
729                    max: 10000usize,
730                    actual: <str>::len(value.as_ref()),
731                });
732            }
733        }
734        {
735            let value = &self.text;
736            {
737                let count = UnicodeSegmentation::graphemes(value.as_ref(), true).count();
738                if count > 1000usize {
739                    return Err(ConstraintError::MaxGraphemes {
740                        path: ValidationPath::from_field("text"),
741                        max: 1000usize,
742                        actual: count,
743                    });
744                }
745            }
746        }
747        Ok(())
748    }
749}
750
751impl<'a> LexiconSchema for MessageViewSender<'a> {
752    fn nsid() -> &'static str {
753        "chat.bsky.convo.defs"
754    }
755    fn def_name() -> &'static str {
756        "messageViewSender"
757    }
758    fn lexicon_doc() -> LexiconDoc<'static> {
759        lexicon_doc_chat_bsky_convo_defs()
760    }
761    fn validate(&self) -> Result<(), ConstraintError> {
762        Ok(())
763    }
764}
765
766impl<'a> LexiconSchema for ReactionView<'a> {
767    fn nsid() -> &'static str {
768        "chat.bsky.convo.defs"
769    }
770    fn def_name() -> &'static str {
771        "reactionView"
772    }
773    fn lexicon_doc() -> LexiconDoc<'static> {
774        lexicon_doc_chat_bsky_convo_defs()
775    }
776    fn validate(&self) -> Result<(), ConstraintError> {
777        Ok(())
778    }
779}
780
781impl<'a> LexiconSchema for ReactionViewSender<'a> {
782    fn nsid() -> &'static str {
783        "chat.bsky.convo.defs"
784    }
785    fn def_name() -> &'static str {
786        "reactionViewSender"
787    }
788    fn lexicon_doc() -> LexiconDoc<'static> {
789        lexicon_doc_chat_bsky_convo_defs()
790    }
791    fn validate(&self) -> Result<(), ConstraintError> {
792        Ok(())
793    }
794}
795
796pub mod convo_view_state {
797
798    pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
799    #[allow(unused)]
800    use ::core::marker::PhantomData;
801    mod sealed {
802        pub trait Sealed {}
803    }
804    /// State trait tracking which required fields have been set
805    pub trait State: sealed::Sealed {
806        type Id;
807        type UnreadCount;
808        type Muted;
809        type Rev;
810        type Members;
811    }
812    /// Empty state - all required fields are unset
813    pub struct Empty(());
814    impl sealed::Sealed for Empty {}
815    impl State for Empty {
816        type Id = Unset;
817        type UnreadCount = Unset;
818        type Muted = Unset;
819        type Rev = Unset;
820        type Members = Unset;
821    }
822    ///State transition - sets the `id` field to Set
823    pub struct SetId<S: State = Empty>(PhantomData<fn() -> S>);
824    impl<S: State> sealed::Sealed for SetId<S> {}
825    impl<S: State> State for SetId<S> {
826        type Id = Set<members::id>;
827        type UnreadCount = S::UnreadCount;
828        type Muted = S::Muted;
829        type Rev = S::Rev;
830        type Members = S::Members;
831    }
832    ///State transition - sets the `unread_count` field to Set
833    pub struct SetUnreadCount<S: State = Empty>(PhantomData<fn() -> S>);
834    impl<S: State> sealed::Sealed for SetUnreadCount<S> {}
835    impl<S: State> State for SetUnreadCount<S> {
836        type Id = S::Id;
837        type UnreadCount = Set<members::unread_count>;
838        type Muted = S::Muted;
839        type Rev = S::Rev;
840        type Members = S::Members;
841    }
842    ///State transition - sets the `muted` field to Set
843    pub struct SetMuted<S: State = Empty>(PhantomData<fn() -> S>);
844    impl<S: State> sealed::Sealed for SetMuted<S> {}
845    impl<S: State> State for SetMuted<S> {
846        type Id = S::Id;
847        type UnreadCount = S::UnreadCount;
848        type Muted = Set<members::muted>;
849        type Rev = S::Rev;
850        type Members = S::Members;
851    }
852    ///State transition - sets the `rev` field to Set
853    pub struct SetRev<S: State = Empty>(PhantomData<fn() -> S>);
854    impl<S: State> sealed::Sealed for SetRev<S> {}
855    impl<S: State> State for SetRev<S> {
856        type Id = S::Id;
857        type UnreadCount = S::UnreadCount;
858        type Muted = S::Muted;
859        type Rev = Set<members::rev>;
860        type Members = S::Members;
861    }
862    ///State transition - sets the `members` field to Set
863    pub struct SetMembers<S: State = Empty>(PhantomData<fn() -> S>);
864    impl<S: State> sealed::Sealed for SetMembers<S> {}
865    impl<S: State> State for SetMembers<S> {
866        type Id = S::Id;
867        type UnreadCount = S::UnreadCount;
868        type Muted = S::Muted;
869        type Rev = S::Rev;
870        type Members = Set<members::members>;
871    }
872    /// Marker types for field names
873    #[allow(non_camel_case_types)]
874    pub mod members {
875        ///Marker type for the `id` field
876        pub struct id(());
877        ///Marker type for the `unread_count` field
878        pub struct unread_count(());
879        ///Marker type for the `muted` field
880        pub struct muted(());
881        ///Marker type for the `rev` field
882        pub struct rev(());
883        ///Marker type for the `members` field
884        pub struct members(());
885    }
886}
887
888/// Builder for constructing an instance of this type
889pub struct ConvoViewBuilder<'a, S: convo_view_state::State> {
890    _state: PhantomData<fn() -> S>,
891    _fields: (
892        Option<CowStr<'a>>,
893        Option<ConvoViewLastMessage<'a>>,
894        Option<convo::MessageAndReactionView<'a>>,
895        Option<Vec<ProfileViewBasic<'a>>>,
896        Option<bool>,
897        Option<CowStr<'a>>,
898        Option<ConvoViewStatus<'a>>,
899        Option<i64>,
900    ),
901    _lifetime: PhantomData<&'a ()>,
902}
903
904impl<'a> ConvoView<'a> {
905    /// Create a new builder for this type
906    pub fn new() -> ConvoViewBuilder<'a, convo_view_state::Empty> {
907        ConvoViewBuilder::new()
908    }
909}
910
911impl<'a> ConvoViewBuilder<'a, convo_view_state::Empty> {
912    /// Create a new builder with all fields unset
913    pub fn new() -> Self {
914        ConvoViewBuilder {
915            _state: PhantomData,
916            _fields: (None, None, None, None, None, None, None, None),
917            _lifetime: PhantomData,
918        }
919    }
920}
921
922impl<'a, S> ConvoViewBuilder<'a, S>
923where
924    S: convo_view_state::State,
925    S::Id: convo_view_state::IsUnset,
926{
927    /// Set the `id` field (required)
928    pub fn id(
929        mut self,
930        value: impl Into<CowStr<'a>>,
931    ) -> ConvoViewBuilder<'a, convo_view_state::SetId<S>> {
932        self._fields.0 = Option::Some(value.into());
933        ConvoViewBuilder {
934            _state: PhantomData,
935            _fields: self._fields,
936            _lifetime: PhantomData,
937        }
938    }
939}
940
941impl<'a, S: convo_view_state::State> ConvoViewBuilder<'a, S> {
942    /// Set the `lastMessage` field (optional)
943    pub fn last_message(
944        mut self,
945        value: impl Into<Option<ConvoViewLastMessage<'a>>>,
946    ) -> Self {
947        self._fields.1 = value.into();
948        self
949    }
950    /// Set the `lastMessage` field to an Option value (optional)
951    pub fn maybe_last_message(
952        mut self,
953        value: Option<ConvoViewLastMessage<'a>>,
954    ) -> Self {
955        self._fields.1 = value;
956        self
957    }
958}
959
960impl<'a, S: convo_view_state::State> ConvoViewBuilder<'a, S> {
961    /// Set the `lastReaction` field (optional)
962    pub fn last_reaction(
963        mut self,
964        value: impl Into<Option<convo::MessageAndReactionView<'a>>>,
965    ) -> Self {
966        self._fields.2 = value.into();
967        self
968    }
969    /// Set the `lastReaction` field to an Option value (optional)
970    pub fn maybe_last_reaction(
971        mut self,
972        value: Option<convo::MessageAndReactionView<'a>>,
973    ) -> Self {
974        self._fields.2 = value;
975        self
976    }
977}
978
979impl<'a, S> ConvoViewBuilder<'a, S>
980where
981    S: convo_view_state::State,
982    S::Members: convo_view_state::IsUnset,
983{
984    /// Set the `members` field (required)
985    pub fn members(
986        mut self,
987        value: impl Into<Vec<ProfileViewBasic<'a>>>,
988    ) -> ConvoViewBuilder<'a, convo_view_state::SetMembers<S>> {
989        self._fields.3 = Option::Some(value.into());
990        ConvoViewBuilder {
991            _state: PhantomData,
992            _fields: self._fields,
993            _lifetime: PhantomData,
994        }
995    }
996}
997
998impl<'a, S> ConvoViewBuilder<'a, S>
999where
1000    S: convo_view_state::State,
1001    S::Muted: convo_view_state::IsUnset,
1002{
1003    /// Set the `muted` field (required)
1004    pub fn muted(
1005        mut self,
1006        value: impl Into<bool>,
1007    ) -> ConvoViewBuilder<'a, convo_view_state::SetMuted<S>> {
1008        self._fields.4 = Option::Some(value.into());
1009        ConvoViewBuilder {
1010            _state: PhantomData,
1011            _fields: self._fields,
1012            _lifetime: PhantomData,
1013        }
1014    }
1015}
1016
1017impl<'a, S> ConvoViewBuilder<'a, S>
1018where
1019    S: convo_view_state::State,
1020    S::Rev: convo_view_state::IsUnset,
1021{
1022    /// Set the `rev` field (required)
1023    pub fn rev(
1024        mut self,
1025        value: impl Into<CowStr<'a>>,
1026    ) -> ConvoViewBuilder<'a, convo_view_state::SetRev<S>> {
1027        self._fields.5 = Option::Some(value.into());
1028        ConvoViewBuilder {
1029            _state: PhantomData,
1030            _fields: self._fields,
1031            _lifetime: PhantomData,
1032        }
1033    }
1034}
1035
1036impl<'a, S: convo_view_state::State> ConvoViewBuilder<'a, S> {
1037    /// Set the `status` field (optional)
1038    pub fn status(mut self, value: impl Into<Option<ConvoViewStatus<'a>>>) -> Self {
1039        self._fields.6 = value.into();
1040        self
1041    }
1042    /// Set the `status` field to an Option value (optional)
1043    pub fn maybe_status(mut self, value: Option<ConvoViewStatus<'a>>) -> Self {
1044        self._fields.6 = value;
1045        self
1046    }
1047}
1048
1049impl<'a, S> ConvoViewBuilder<'a, S>
1050where
1051    S: convo_view_state::State,
1052    S::UnreadCount: convo_view_state::IsUnset,
1053{
1054    /// Set the `unreadCount` field (required)
1055    pub fn unread_count(
1056        mut self,
1057        value: impl Into<i64>,
1058    ) -> ConvoViewBuilder<'a, convo_view_state::SetUnreadCount<S>> {
1059        self._fields.7 = Option::Some(value.into());
1060        ConvoViewBuilder {
1061            _state: PhantomData,
1062            _fields: self._fields,
1063            _lifetime: PhantomData,
1064        }
1065    }
1066}
1067
1068impl<'a, S> ConvoViewBuilder<'a, S>
1069where
1070    S: convo_view_state::State,
1071    S::Id: convo_view_state::IsSet,
1072    S::UnreadCount: convo_view_state::IsSet,
1073    S::Muted: convo_view_state::IsSet,
1074    S::Rev: convo_view_state::IsSet,
1075    S::Members: convo_view_state::IsSet,
1076{
1077    /// Build the final struct
1078    pub fn build(self) -> ConvoView<'a> {
1079        ConvoView {
1080            id: self._fields.0.unwrap(),
1081            last_message: self._fields.1,
1082            last_reaction: self._fields.2,
1083            members: self._fields.3.unwrap(),
1084            muted: self._fields.4.unwrap(),
1085            rev: self._fields.5.unwrap(),
1086            status: self._fields.6,
1087            unread_count: self._fields.7.unwrap(),
1088            extra_data: Default::default(),
1089        }
1090    }
1091    /// Build the final struct with custom extra_data
1092    pub fn build_with_data(
1093        self,
1094        extra_data: BTreeMap<
1095            jacquard_common::deps::smol_str::SmolStr,
1096            jacquard_common::types::value::Data<'a>,
1097        >,
1098    ) -> ConvoView<'a> {
1099        ConvoView {
1100            id: self._fields.0.unwrap(),
1101            last_message: self._fields.1,
1102            last_reaction: self._fields.2,
1103            members: self._fields.3.unwrap(),
1104            muted: self._fields.4.unwrap(),
1105            rev: self._fields.5.unwrap(),
1106            status: self._fields.6,
1107            unread_count: self._fields.7.unwrap(),
1108            extra_data: Some(extra_data),
1109        }
1110    }
1111}
1112
1113fn lexicon_doc_chat_bsky_convo_defs() -> LexiconDoc<'static> {
1114    #[allow(unused_imports)]
1115    use jacquard_common::{CowStr, deps::smol_str::SmolStr, types::blob::MimeType};
1116    use jacquard_lexicon::lexicon::*;
1117    use alloc::collections::BTreeMap;
1118    LexiconDoc {
1119        lexicon: Lexicon::Lexicon1,
1120        id: CowStr::new_static("chat.bsky.convo.defs"),
1121        defs: {
1122            let mut map = BTreeMap::new();
1123            map.insert(
1124                SmolStr::new_static("convoView"),
1125                LexUserType::Object(LexObject {
1126                    required: Some(
1127                        vec![
1128                            SmolStr::new_static("id"), SmolStr::new_static("rev"),
1129                            SmolStr::new_static("members"), SmolStr::new_static("muted"),
1130                            SmolStr::new_static("unreadCount")
1131                        ],
1132                    ),
1133                    properties: {
1134                        #[allow(unused_mut)]
1135                        let mut map = BTreeMap::new();
1136                        map.insert(
1137                            SmolStr::new_static("id"),
1138                            LexObjectProperty::String(LexString { ..Default::default() }),
1139                        );
1140                        map.insert(
1141                            SmolStr::new_static("lastMessage"),
1142                            LexObjectProperty::Union(LexRefUnion {
1143                                refs: vec![
1144                                    CowStr::new_static("#messageView"),
1145                                    CowStr::new_static("#deletedMessageView")
1146                                ],
1147                                ..Default::default()
1148                            }),
1149                        );
1150                        map.insert(
1151                            SmolStr::new_static("lastReaction"),
1152                            LexObjectProperty::Union(LexRefUnion {
1153                                refs: vec![CowStr::new_static("#messageAndReactionView")],
1154                                ..Default::default()
1155                            }),
1156                        );
1157                        map.insert(
1158                            SmolStr::new_static("members"),
1159                            LexObjectProperty::Array(LexArray {
1160                                items: LexArrayItem::Ref(LexRef {
1161                                    r#ref: CowStr::new_static(
1162                                        "chat.bsky.actor.defs#profileViewBasic",
1163                                    ),
1164                                    ..Default::default()
1165                                }),
1166                                ..Default::default()
1167                            }),
1168                        );
1169                        map.insert(
1170                            SmolStr::new_static("muted"),
1171                            LexObjectProperty::Boolean(LexBoolean {
1172                                ..Default::default()
1173                            }),
1174                        );
1175                        map.insert(
1176                            SmolStr::new_static("rev"),
1177                            LexObjectProperty::String(LexString { ..Default::default() }),
1178                        );
1179                        map.insert(
1180                            SmolStr::new_static("status"),
1181                            LexObjectProperty::String(LexString { ..Default::default() }),
1182                        );
1183                        map.insert(
1184                            SmolStr::new_static("unreadCount"),
1185                            LexObjectProperty::Integer(LexInteger {
1186                                ..Default::default()
1187                            }),
1188                        );
1189                        map
1190                    },
1191                    ..Default::default()
1192                }),
1193            );
1194            map.insert(
1195                SmolStr::new_static("deletedMessageView"),
1196                LexUserType::Object(LexObject {
1197                    required: Some(
1198                        vec![
1199                            SmolStr::new_static("id"), SmolStr::new_static("rev"),
1200                            SmolStr::new_static("sender"), SmolStr::new_static("sentAt")
1201                        ],
1202                    ),
1203                    properties: {
1204                        #[allow(unused_mut)]
1205                        let mut map = BTreeMap::new();
1206                        map.insert(
1207                            SmolStr::new_static("id"),
1208                            LexObjectProperty::String(LexString { ..Default::default() }),
1209                        );
1210                        map.insert(
1211                            SmolStr::new_static("rev"),
1212                            LexObjectProperty::String(LexString { ..Default::default() }),
1213                        );
1214                        map.insert(
1215                            SmolStr::new_static("sender"),
1216                            LexObjectProperty::Ref(LexRef {
1217                                r#ref: CowStr::new_static("#messageViewSender"),
1218                                ..Default::default()
1219                            }),
1220                        );
1221                        map.insert(
1222                            SmolStr::new_static("sentAt"),
1223                            LexObjectProperty::String(LexString {
1224                                format: Some(LexStringFormat::Datetime),
1225                                ..Default::default()
1226                            }),
1227                        );
1228                        map
1229                    },
1230                    ..Default::default()
1231                }),
1232            );
1233            map.insert(
1234                SmolStr::new_static("logAcceptConvo"),
1235                LexUserType::Object(LexObject {
1236                    required: Some(
1237                        vec![SmolStr::new_static("rev"), SmolStr::new_static("convoId")],
1238                    ),
1239                    properties: {
1240                        #[allow(unused_mut)]
1241                        let mut map = BTreeMap::new();
1242                        map.insert(
1243                            SmolStr::new_static("convoId"),
1244                            LexObjectProperty::String(LexString { ..Default::default() }),
1245                        );
1246                        map.insert(
1247                            SmolStr::new_static("rev"),
1248                            LexObjectProperty::String(LexString { ..Default::default() }),
1249                        );
1250                        map
1251                    },
1252                    ..Default::default()
1253                }),
1254            );
1255            map.insert(
1256                SmolStr::new_static("logAddReaction"),
1257                LexUserType::Object(LexObject {
1258                    required: Some(
1259                        vec![
1260                            SmolStr::new_static("rev"), SmolStr::new_static("convoId"),
1261                            SmolStr::new_static("message"),
1262                            SmolStr::new_static("reaction")
1263                        ],
1264                    ),
1265                    properties: {
1266                        #[allow(unused_mut)]
1267                        let mut map = BTreeMap::new();
1268                        map.insert(
1269                            SmolStr::new_static("convoId"),
1270                            LexObjectProperty::String(LexString { ..Default::default() }),
1271                        );
1272                        map.insert(
1273                            SmolStr::new_static("message"),
1274                            LexObjectProperty::Union(LexRefUnion {
1275                                refs: vec![
1276                                    CowStr::new_static("#messageView"),
1277                                    CowStr::new_static("#deletedMessageView")
1278                                ],
1279                                ..Default::default()
1280                            }),
1281                        );
1282                        map.insert(
1283                            SmolStr::new_static("reaction"),
1284                            LexObjectProperty::Ref(LexRef {
1285                                r#ref: CowStr::new_static("#reactionView"),
1286                                ..Default::default()
1287                            }),
1288                        );
1289                        map.insert(
1290                            SmolStr::new_static("rev"),
1291                            LexObjectProperty::String(LexString { ..Default::default() }),
1292                        );
1293                        map
1294                    },
1295                    ..Default::default()
1296                }),
1297            );
1298            map.insert(
1299                SmolStr::new_static("logBeginConvo"),
1300                LexUserType::Object(LexObject {
1301                    required: Some(
1302                        vec![SmolStr::new_static("rev"), SmolStr::new_static("convoId")],
1303                    ),
1304                    properties: {
1305                        #[allow(unused_mut)]
1306                        let mut map = BTreeMap::new();
1307                        map.insert(
1308                            SmolStr::new_static("convoId"),
1309                            LexObjectProperty::String(LexString { ..Default::default() }),
1310                        );
1311                        map.insert(
1312                            SmolStr::new_static("rev"),
1313                            LexObjectProperty::String(LexString { ..Default::default() }),
1314                        );
1315                        map
1316                    },
1317                    ..Default::default()
1318                }),
1319            );
1320            map.insert(
1321                SmolStr::new_static("logCreateMessage"),
1322                LexUserType::Object(LexObject {
1323                    required: Some(
1324                        vec![
1325                            SmolStr::new_static("rev"), SmolStr::new_static("convoId"),
1326                            SmolStr::new_static("message")
1327                        ],
1328                    ),
1329                    properties: {
1330                        #[allow(unused_mut)]
1331                        let mut map = BTreeMap::new();
1332                        map.insert(
1333                            SmolStr::new_static("convoId"),
1334                            LexObjectProperty::String(LexString { ..Default::default() }),
1335                        );
1336                        map.insert(
1337                            SmolStr::new_static("message"),
1338                            LexObjectProperty::Union(LexRefUnion {
1339                                refs: vec![
1340                                    CowStr::new_static("#messageView"),
1341                                    CowStr::new_static("#deletedMessageView")
1342                                ],
1343                                ..Default::default()
1344                            }),
1345                        );
1346                        map.insert(
1347                            SmolStr::new_static("rev"),
1348                            LexObjectProperty::String(LexString { ..Default::default() }),
1349                        );
1350                        map
1351                    },
1352                    ..Default::default()
1353                }),
1354            );
1355            map.insert(
1356                SmolStr::new_static("logDeleteMessage"),
1357                LexUserType::Object(LexObject {
1358                    required: Some(
1359                        vec![
1360                            SmolStr::new_static("rev"), SmolStr::new_static("convoId"),
1361                            SmolStr::new_static("message")
1362                        ],
1363                    ),
1364                    properties: {
1365                        #[allow(unused_mut)]
1366                        let mut map = BTreeMap::new();
1367                        map.insert(
1368                            SmolStr::new_static("convoId"),
1369                            LexObjectProperty::String(LexString { ..Default::default() }),
1370                        );
1371                        map.insert(
1372                            SmolStr::new_static("message"),
1373                            LexObjectProperty::Union(LexRefUnion {
1374                                refs: vec![
1375                                    CowStr::new_static("#messageView"),
1376                                    CowStr::new_static("#deletedMessageView")
1377                                ],
1378                                ..Default::default()
1379                            }),
1380                        );
1381                        map.insert(
1382                            SmolStr::new_static("rev"),
1383                            LexObjectProperty::String(LexString { ..Default::default() }),
1384                        );
1385                        map
1386                    },
1387                    ..Default::default()
1388                }),
1389            );
1390            map.insert(
1391                SmolStr::new_static("logLeaveConvo"),
1392                LexUserType::Object(LexObject {
1393                    required: Some(
1394                        vec![SmolStr::new_static("rev"), SmolStr::new_static("convoId")],
1395                    ),
1396                    properties: {
1397                        #[allow(unused_mut)]
1398                        let mut map = BTreeMap::new();
1399                        map.insert(
1400                            SmolStr::new_static("convoId"),
1401                            LexObjectProperty::String(LexString { ..Default::default() }),
1402                        );
1403                        map.insert(
1404                            SmolStr::new_static("rev"),
1405                            LexObjectProperty::String(LexString { ..Default::default() }),
1406                        );
1407                        map
1408                    },
1409                    ..Default::default()
1410                }),
1411            );
1412            map.insert(
1413                SmolStr::new_static("logMuteConvo"),
1414                LexUserType::Object(LexObject {
1415                    required: Some(
1416                        vec![SmolStr::new_static("rev"), SmolStr::new_static("convoId")],
1417                    ),
1418                    properties: {
1419                        #[allow(unused_mut)]
1420                        let mut map = BTreeMap::new();
1421                        map.insert(
1422                            SmolStr::new_static("convoId"),
1423                            LexObjectProperty::String(LexString { ..Default::default() }),
1424                        );
1425                        map.insert(
1426                            SmolStr::new_static("rev"),
1427                            LexObjectProperty::String(LexString { ..Default::default() }),
1428                        );
1429                        map
1430                    },
1431                    ..Default::default()
1432                }),
1433            );
1434            map.insert(
1435                SmolStr::new_static("logReadMessage"),
1436                LexUserType::Object(LexObject {
1437                    required: Some(
1438                        vec![
1439                            SmolStr::new_static("rev"), SmolStr::new_static("convoId"),
1440                            SmolStr::new_static("message")
1441                        ],
1442                    ),
1443                    properties: {
1444                        #[allow(unused_mut)]
1445                        let mut map = BTreeMap::new();
1446                        map.insert(
1447                            SmolStr::new_static("convoId"),
1448                            LexObjectProperty::String(LexString { ..Default::default() }),
1449                        );
1450                        map.insert(
1451                            SmolStr::new_static("message"),
1452                            LexObjectProperty::Union(LexRefUnion {
1453                                refs: vec![
1454                                    CowStr::new_static("#messageView"),
1455                                    CowStr::new_static("#deletedMessageView")
1456                                ],
1457                                ..Default::default()
1458                            }),
1459                        );
1460                        map.insert(
1461                            SmolStr::new_static("rev"),
1462                            LexObjectProperty::String(LexString { ..Default::default() }),
1463                        );
1464                        map
1465                    },
1466                    ..Default::default()
1467                }),
1468            );
1469            map.insert(
1470                SmolStr::new_static("logRemoveReaction"),
1471                LexUserType::Object(LexObject {
1472                    required: Some(
1473                        vec![
1474                            SmolStr::new_static("rev"), SmolStr::new_static("convoId"),
1475                            SmolStr::new_static("message"),
1476                            SmolStr::new_static("reaction")
1477                        ],
1478                    ),
1479                    properties: {
1480                        #[allow(unused_mut)]
1481                        let mut map = BTreeMap::new();
1482                        map.insert(
1483                            SmolStr::new_static("convoId"),
1484                            LexObjectProperty::String(LexString { ..Default::default() }),
1485                        );
1486                        map.insert(
1487                            SmolStr::new_static("message"),
1488                            LexObjectProperty::Union(LexRefUnion {
1489                                refs: vec![
1490                                    CowStr::new_static("#messageView"),
1491                                    CowStr::new_static("#deletedMessageView")
1492                                ],
1493                                ..Default::default()
1494                            }),
1495                        );
1496                        map.insert(
1497                            SmolStr::new_static("reaction"),
1498                            LexObjectProperty::Ref(LexRef {
1499                                r#ref: CowStr::new_static("#reactionView"),
1500                                ..Default::default()
1501                            }),
1502                        );
1503                        map.insert(
1504                            SmolStr::new_static("rev"),
1505                            LexObjectProperty::String(LexString { ..Default::default() }),
1506                        );
1507                        map
1508                    },
1509                    ..Default::default()
1510                }),
1511            );
1512            map.insert(
1513                SmolStr::new_static("logUnmuteConvo"),
1514                LexUserType::Object(LexObject {
1515                    required: Some(
1516                        vec![SmolStr::new_static("rev"), SmolStr::new_static("convoId")],
1517                    ),
1518                    properties: {
1519                        #[allow(unused_mut)]
1520                        let mut map = BTreeMap::new();
1521                        map.insert(
1522                            SmolStr::new_static("convoId"),
1523                            LexObjectProperty::String(LexString { ..Default::default() }),
1524                        );
1525                        map.insert(
1526                            SmolStr::new_static("rev"),
1527                            LexObjectProperty::String(LexString { ..Default::default() }),
1528                        );
1529                        map
1530                    },
1531                    ..Default::default()
1532                }),
1533            );
1534            map.insert(
1535                SmolStr::new_static("messageAndReactionView"),
1536                LexUserType::Object(LexObject {
1537                    required: Some(
1538                        vec![
1539                            SmolStr::new_static("message"),
1540                            SmolStr::new_static("reaction")
1541                        ],
1542                    ),
1543                    properties: {
1544                        #[allow(unused_mut)]
1545                        let mut map = BTreeMap::new();
1546                        map.insert(
1547                            SmolStr::new_static("message"),
1548                            LexObjectProperty::Ref(LexRef {
1549                                r#ref: CowStr::new_static("#messageView"),
1550                                ..Default::default()
1551                            }),
1552                        );
1553                        map.insert(
1554                            SmolStr::new_static("reaction"),
1555                            LexObjectProperty::Ref(LexRef {
1556                                r#ref: CowStr::new_static("#reactionView"),
1557                                ..Default::default()
1558                            }),
1559                        );
1560                        map
1561                    },
1562                    ..Default::default()
1563                }),
1564            );
1565            map.insert(
1566                SmolStr::new_static("messageInput"),
1567                LexUserType::Object(LexObject {
1568                    required: Some(vec![SmolStr::new_static("text")]),
1569                    properties: {
1570                        #[allow(unused_mut)]
1571                        let mut map = BTreeMap::new();
1572                        map.insert(
1573                            SmolStr::new_static("embed"),
1574                            LexObjectProperty::Union(LexRefUnion {
1575                                refs: vec![CowStr::new_static("app.bsky.embed.record")],
1576                                ..Default::default()
1577                            }),
1578                        );
1579                        map.insert(
1580                            SmolStr::new_static("facets"),
1581                            LexObjectProperty::Array(LexArray {
1582                                description: Some(
1583                                    CowStr::new_static(
1584                                        "Annotations of text (mentions, URLs, hashtags, etc)",
1585                                    ),
1586                                ),
1587                                items: LexArrayItem::Ref(LexRef {
1588                                    r#ref: CowStr::new_static("app.bsky.richtext.facet"),
1589                                    ..Default::default()
1590                                }),
1591                                ..Default::default()
1592                            }),
1593                        );
1594                        map.insert(
1595                            SmolStr::new_static("text"),
1596                            LexObjectProperty::String(LexString {
1597                                max_length: Some(10000usize),
1598                                max_graphemes: Some(1000usize),
1599                                ..Default::default()
1600                            }),
1601                        );
1602                        map
1603                    },
1604                    ..Default::default()
1605                }),
1606            );
1607            map.insert(
1608                SmolStr::new_static("messageRef"),
1609                LexUserType::Object(LexObject {
1610                    required: Some(
1611                        vec![
1612                            SmolStr::new_static("did"), SmolStr::new_static("messageId"),
1613                            SmolStr::new_static("convoId")
1614                        ],
1615                    ),
1616                    properties: {
1617                        #[allow(unused_mut)]
1618                        let mut map = BTreeMap::new();
1619                        map.insert(
1620                            SmolStr::new_static("convoId"),
1621                            LexObjectProperty::String(LexString { ..Default::default() }),
1622                        );
1623                        map.insert(
1624                            SmolStr::new_static("did"),
1625                            LexObjectProperty::String(LexString {
1626                                format: Some(LexStringFormat::Did),
1627                                ..Default::default()
1628                            }),
1629                        );
1630                        map.insert(
1631                            SmolStr::new_static("messageId"),
1632                            LexObjectProperty::String(LexString { ..Default::default() }),
1633                        );
1634                        map
1635                    },
1636                    ..Default::default()
1637                }),
1638            );
1639            map.insert(
1640                SmolStr::new_static("messageView"),
1641                LexUserType::Object(LexObject {
1642                    required: Some(
1643                        vec![
1644                            SmolStr::new_static("id"), SmolStr::new_static("rev"),
1645                            SmolStr::new_static("text"), SmolStr::new_static("sender"),
1646                            SmolStr::new_static("sentAt")
1647                        ],
1648                    ),
1649                    properties: {
1650                        #[allow(unused_mut)]
1651                        let mut map = BTreeMap::new();
1652                        map.insert(
1653                            SmolStr::new_static("embed"),
1654                            LexObjectProperty::Union(LexRefUnion {
1655                                refs: vec![
1656                                    CowStr::new_static("app.bsky.embed.record#view")
1657                                ],
1658                                ..Default::default()
1659                            }),
1660                        );
1661                        map.insert(
1662                            SmolStr::new_static("facets"),
1663                            LexObjectProperty::Array(LexArray {
1664                                description: Some(
1665                                    CowStr::new_static(
1666                                        "Annotations of text (mentions, URLs, hashtags, etc)",
1667                                    ),
1668                                ),
1669                                items: LexArrayItem::Ref(LexRef {
1670                                    r#ref: CowStr::new_static("app.bsky.richtext.facet"),
1671                                    ..Default::default()
1672                                }),
1673                                ..Default::default()
1674                            }),
1675                        );
1676                        map.insert(
1677                            SmolStr::new_static("id"),
1678                            LexObjectProperty::String(LexString { ..Default::default() }),
1679                        );
1680                        map.insert(
1681                            SmolStr::new_static("reactions"),
1682                            LexObjectProperty::Array(LexArray {
1683                                description: Some(
1684                                    CowStr::new_static(
1685                                        "Reactions to this message, in ascending order of creation time.",
1686                                    ),
1687                                ),
1688                                items: LexArrayItem::Ref(LexRef {
1689                                    r#ref: CowStr::new_static("#reactionView"),
1690                                    ..Default::default()
1691                                }),
1692                                ..Default::default()
1693                            }),
1694                        );
1695                        map.insert(
1696                            SmolStr::new_static("rev"),
1697                            LexObjectProperty::String(LexString { ..Default::default() }),
1698                        );
1699                        map.insert(
1700                            SmolStr::new_static("sender"),
1701                            LexObjectProperty::Ref(LexRef {
1702                                r#ref: CowStr::new_static("#messageViewSender"),
1703                                ..Default::default()
1704                            }),
1705                        );
1706                        map.insert(
1707                            SmolStr::new_static("sentAt"),
1708                            LexObjectProperty::String(LexString {
1709                                format: Some(LexStringFormat::Datetime),
1710                                ..Default::default()
1711                            }),
1712                        );
1713                        map.insert(
1714                            SmolStr::new_static("text"),
1715                            LexObjectProperty::String(LexString {
1716                                max_length: Some(10000usize),
1717                                max_graphemes: Some(1000usize),
1718                                ..Default::default()
1719                            }),
1720                        );
1721                        map
1722                    },
1723                    ..Default::default()
1724                }),
1725            );
1726            map.insert(
1727                SmolStr::new_static("messageViewSender"),
1728                LexUserType::Object(LexObject {
1729                    required: Some(vec![SmolStr::new_static("did")]),
1730                    properties: {
1731                        #[allow(unused_mut)]
1732                        let mut map = BTreeMap::new();
1733                        map.insert(
1734                            SmolStr::new_static("did"),
1735                            LexObjectProperty::String(LexString {
1736                                format: Some(LexStringFormat::Did),
1737                                ..Default::default()
1738                            }),
1739                        );
1740                        map
1741                    },
1742                    ..Default::default()
1743                }),
1744            );
1745            map.insert(
1746                SmolStr::new_static("reactionView"),
1747                LexUserType::Object(LexObject {
1748                    required: Some(
1749                        vec![
1750                            SmolStr::new_static("value"), SmolStr::new_static("sender"),
1751                            SmolStr::new_static("createdAt")
1752                        ],
1753                    ),
1754                    properties: {
1755                        #[allow(unused_mut)]
1756                        let mut map = BTreeMap::new();
1757                        map.insert(
1758                            SmolStr::new_static("createdAt"),
1759                            LexObjectProperty::String(LexString {
1760                                format: Some(LexStringFormat::Datetime),
1761                                ..Default::default()
1762                            }),
1763                        );
1764                        map.insert(
1765                            SmolStr::new_static("sender"),
1766                            LexObjectProperty::Ref(LexRef {
1767                                r#ref: CowStr::new_static("#reactionViewSender"),
1768                                ..Default::default()
1769                            }),
1770                        );
1771                        map.insert(
1772                            SmolStr::new_static("value"),
1773                            LexObjectProperty::String(LexString { ..Default::default() }),
1774                        );
1775                        map
1776                    },
1777                    ..Default::default()
1778                }),
1779            );
1780            map.insert(
1781                SmolStr::new_static("reactionViewSender"),
1782                LexUserType::Object(LexObject {
1783                    required: Some(vec![SmolStr::new_static("did")]),
1784                    properties: {
1785                        #[allow(unused_mut)]
1786                        let mut map = BTreeMap::new();
1787                        map.insert(
1788                            SmolStr::new_static("did"),
1789                            LexObjectProperty::String(LexString {
1790                                format: Some(LexStringFormat::Did),
1791                                ..Default::default()
1792                            }),
1793                        );
1794                        map
1795                    },
1796                    ..Default::default()
1797                }),
1798            );
1799            map
1800        },
1801        ..Default::default()
1802    }
1803}
1804
1805pub mod deleted_message_view_state {
1806
1807    pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
1808    #[allow(unused)]
1809    use ::core::marker::PhantomData;
1810    mod sealed {
1811        pub trait Sealed {}
1812    }
1813    /// State trait tracking which required fields have been set
1814    pub trait State: sealed::Sealed {
1815        type Rev;
1816        type SentAt;
1817        type Id;
1818        type Sender;
1819    }
1820    /// Empty state - all required fields are unset
1821    pub struct Empty(());
1822    impl sealed::Sealed for Empty {}
1823    impl State for Empty {
1824        type Rev = Unset;
1825        type SentAt = Unset;
1826        type Id = Unset;
1827        type Sender = Unset;
1828    }
1829    ///State transition - sets the `rev` field to Set
1830    pub struct SetRev<S: State = Empty>(PhantomData<fn() -> S>);
1831    impl<S: State> sealed::Sealed for SetRev<S> {}
1832    impl<S: State> State for SetRev<S> {
1833        type Rev = Set<members::rev>;
1834        type SentAt = S::SentAt;
1835        type Id = S::Id;
1836        type Sender = S::Sender;
1837    }
1838    ///State transition - sets the `sent_at` field to Set
1839    pub struct SetSentAt<S: State = Empty>(PhantomData<fn() -> S>);
1840    impl<S: State> sealed::Sealed for SetSentAt<S> {}
1841    impl<S: State> State for SetSentAt<S> {
1842        type Rev = S::Rev;
1843        type SentAt = Set<members::sent_at>;
1844        type Id = S::Id;
1845        type Sender = S::Sender;
1846    }
1847    ///State transition - sets the `id` field to Set
1848    pub struct SetId<S: State = Empty>(PhantomData<fn() -> S>);
1849    impl<S: State> sealed::Sealed for SetId<S> {}
1850    impl<S: State> State for SetId<S> {
1851        type Rev = S::Rev;
1852        type SentAt = S::SentAt;
1853        type Id = Set<members::id>;
1854        type Sender = S::Sender;
1855    }
1856    ///State transition - sets the `sender` field to Set
1857    pub struct SetSender<S: State = Empty>(PhantomData<fn() -> S>);
1858    impl<S: State> sealed::Sealed for SetSender<S> {}
1859    impl<S: State> State for SetSender<S> {
1860        type Rev = S::Rev;
1861        type SentAt = S::SentAt;
1862        type Id = S::Id;
1863        type Sender = Set<members::sender>;
1864    }
1865    /// Marker types for field names
1866    #[allow(non_camel_case_types)]
1867    pub mod members {
1868        ///Marker type for the `rev` field
1869        pub struct rev(());
1870        ///Marker type for the `sent_at` field
1871        pub struct sent_at(());
1872        ///Marker type for the `id` field
1873        pub struct id(());
1874        ///Marker type for the `sender` field
1875        pub struct sender(());
1876    }
1877}
1878
1879/// Builder for constructing an instance of this type
1880pub struct DeletedMessageViewBuilder<'a, S: deleted_message_view_state::State> {
1881    _state: PhantomData<fn() -> S>,
1882    _fields: (
1883        Option<CowStr<'a>>,
1884        Option<CowStr<'a>>,
1885        Option<convo::MessageViewSender<'a>>,
1886        Option<Datetime>,
1887    ),
1888    _lifetime: PhantomData<&'a ()>,
1889}
1890
1891impl<'a> DeletedMessageView<'a> {
1892    /// Create a new builder for this type
1893    pub fn new() -> DeletedMessageViewBuilder<'a, deleted_message_view_state::Empty> {
1894        DeletedMessageViewBuilder::new()
1895    }
1896}
1897
1898impl<'a> DeletedMessageViewBuilder<'a, deleted_message_view_state::Empty> {
1899    /// Create a new builder with all fields unset
1900    pub fn new() -> Self {
1901        DeletedMessageViewBuilder {
1902            _state: PhantomData,
1903            _fields: (None, None, None, None),
1904            _lifetime: PhantomData,
1905        }
1906    }
1907}
1908
1909impl<'a, S> DeletedMessageViewBuilder<'a, S>
1910where
1911    S: deleted_message_view_state::State,
1912    S::Id: deleted_message_view_state::IsUnset,
1913{
1914    /// Set the `id` field (required)
1915    pub fn id(
1916        mut self,
1917        value: impl Into<CowStr<'a>>,
1918    ) -> DeletedMessageViewBuilder<'a, deleted_message_view_state::SetId<S>> {
1919        self._fields.0 = Option::Some(value.into());
1920        DeletedMessageViewBuilder {
1921            _state: PhantomData,
1922            _fields: self._fields,
1923            _lifetime: PhantomData,
1924        }
1925    }
1926}
1927
1928impl<'a, S> DeletedMessageViewBuilder<'a, S>
1929where
1930    S: deleted_message_view_state::State,
1931    S::Rev: deleted_message_view_state::IsUnset,
1932{
1933    /// Set the `rev` field (required)
1934    pub fn rev(
1935        mut self,
1936        value: impl Into<CowStr<'a>>,
1937    ) -> DeletedMessageViewBuilder<'a, deleted_message_view_state::SetRev<S>> {
1938        self._fields.1 = Option::Some(value.into());
1939        DeletedMessageViewBuilder {
1940            _state: PhantomData,
1941            _fields: self._fields,
1942            _lifetime: PhantomData,
1943        }
1944    }
1945}
1946
1947impl<'a, S> DeletedMessageViewBuilder<'a, S>
1948where
1949    S: deleted_message_view_state::State,
1950    S::Sender: deleted_message_view_state::IsUnset,
1951{
1952    /// Set the `sender` field (required)
1953    pub fn sender(
1954        mut self,
1955        value: impl Into<convo::MessageViewSender<'a>>,
1956    ) -> DeletedMessageViewBuilder<'a, deleted_message_view_state::SetSender<S>> {
1957        self._fields.2 = Option::Some(value.into());
1958        DeletedMessageViewBuilder {
1959            _state: PhantomData,
1960            _fields: self._fields,
1961            _lifetime: PhantomData,
1962        }
1963    }
1964}
1965
1966impl<'a, S> DeletedMessageViewBuilder<'a, S>
1967where
1968    S: deleted_message_view_state::State,
1969    S::SentAt: deleted_message_view_state::IsUnset,
1970{
1971    /// Set the `sentAt` field (required)
1972    pub fn sent_at(
1973        mut self,
1974        value: impl Into<Datetime>,
1975    ) -> DeletedMessageViewBuilder<'a, deleted_message_view_state::SetSentAt<S>> {
1976        self._fields.3 = Option::Some(value.into());
1977        DeletedMessageViewBuilder {
1978            _state: PhantomData,
1979            _fields: self._fields,
1980            _lifetime: PhantomData,
1981        }
1982    }
1983}
1984
1985impl<'a, S> DeletedMessageViewBuilder<'a, S>
1986where
1987    S: deleted_message_view_state::State,
1988    S::Rev: deleted_message_view_state::IsSet,
1989    S::SentAt: deleted_message_view_state::IsSet,
1990    S::Id: deleted_message_view_state::IsSet,
1991    S::Sender: deleted_message_view_state::IsSet,
1992{
1993    /// Build the final struct
1994    pub fn build(self) -> DeletedMessageView<'a> {
1995        DeletedMessageView {
1996            id: self._fields.0.unwrap(),
1997            rev: self._fields.1.unwrap(),
1998            sender: self._fields.2.unwrap(),
1999            sent_at: self._fields.3.unwrap(),
2000            extra_data: Default::default(),
2001        }
2002    }
2003    /// Build the final struct with custom extra_data
2004    pub fn build_with_data(
2005        self,
2006        extra_data: BTreeMap<
2007            jacquard_common::deps::smol_str::SmolStr,
2008            jacquard_common::types::value::Data<'a>,
2009        >,
2010    ) -> DeletedMessageView<'a> {
2011        DeletedMessageView {
2012            id: self._fields.0.unwrap(),
2013            rev: self._fields.1.unwrap(),
2014            sender: self._fields.2.unwrap(),
2015            sent_at: self._fields.3.unwrap(),
2016            extra_data: Some(extra_data),
2017        }
2018    }
2019}
2020
2021pub mod log_add_reaction_state {
2022
2023    pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
2024    #[allow(unused)]
2025    use ::core::marker::PhantomData;
2026    mod sealed {
2027        pub trait Sealed {}
2028    }
2029    /// State trait tracking which required fields have been set
2030    pub trait State: sealed::Sealed {
2031        type Reaction;
2032        type Rev;
2033        type ConvoId;
2034        type Message;
2035    }
2036    /// Empty state - all required fields are unset
2037    pub struct Empty(());
2038    impl sealed::Sealed for Empty {}
2039    impl State for Empty {
2040        type Reaction = Unset;
2041        type Rev = Unset;
2042        type ConvoId = Unset;
2043        type Message = Unset;
2044    }
2045    ///State transition - sets the `reaction` field to Set
2046    pub struct SetReaction<S: State = Empty>(PhantomData<fn() -> S>);
2047    impl<S: State> sealed::Sealed for SetReaction<S> {}
2048    impl<S: State> State for SetReaction<S> {
2049        type Reaction = Set<members::reaction>;
2050        type Rev = S::Rev;
2051        type ConvoId = S::ConvoId;
2052        type Message = S::Message;
2053    }
2054    ///State transition - sets the `rev` field to Set
2055    pub struct SetRev<S: State = Empty>(PhantomData<fn() -> S>);
2056    impl<S: State> sealed::Sealed for SetRev<S> {}
2057    impl<S: State> State for SetRev<S> {
2058        type Reaction = S::Reaction;
2059        type Rev = Set<members::rev>;
2060        type ConvoId = S::ConvoId;
2061        type Message = S::Message;
2062    }
2063    ///State transition - sets the `convo_id` field to Set
2064    pub struct SetConvoId<S: State = Empty>(PhantomData<fn() -> S>);
2065    impl<S: State> sealed::Sealed for SetConvoId<S> {}
2066    impl<S: State> State for SetConvoId<S> {
2067        type Reaction = S::Reaction;
2068        type Rev = S::Rev;
2069        type ConvoId = Set<members::convo_id>;
2070        type Message = S::Message;
2071    }
2072    ///State transition - sets the `message` field to Set
2073    pub struct SetMessage<S: State = Empty>(PhantomData<fn() -> S>);
2074    impl<S: State> sealed::Sealed for SetMessage<S> {}
2075    impl<S: State> State for SetMessage<S> {
2076        type Reaction = S::Reaction;
2077        type Rev = S::Rev;
2078        type ConvoId = S::ConvoId;
2079        type Message = Set<members::message>;
2080    }
2081    /// Marker types for field names
2082    #[allow(non_camel_case_types)]
2083    pub mod members {
2084        ///Marker type for the `reaction` field
2085        pub struct reaction(());
2086        ///Marker type for the `rev` field
2087        pub struct rev(());
2088        ///Marker type for the `convo_id` field
2089        pub struct convo_id(());
2090        ///Marker type for the `message` field
2091        pub struct message(());
2092    }
2093}
2094
2095/// Builder for constructing an instance of this type
2096pub struct LogAddReactionBuilder<'a, S: log_add_reaction_state::State> {
2097    _state: PhantomData<fn() -> S>,
2098    _fields: (
2099        Option<CowStr<'a>>,
2100        Option<LogAddReactionMessage<'a>>,
2101        Option<convo::ReactionView<'a>>,
2102        Option<CowStr<'a>>,
2103    ),
2104    _lifetime: PhantomData<&'a ()>,
2105}
2106
2107impl<'a> LogAddReaction<'a> {
2108    /// Create a new builder for this type
2109    pub fn new() -> LogAddReactionBuilder<'a, log_add_reaction_state::Empty> {
2110        LogAddReactionBuilder::new()
2111    }
2112}
2113
2114impl<'a> LogAddReactionBuilder<'a, log_add_reaction_state::Empty> {
2115    /// Create a new builder with all fields unset
2116    pub fn new() -> Self {
2117        LogAddReactionBuilder {
2118            _state: PhantomData,
2119            _fields: (None, None, None, None),
2120            _lifetime: PhantomData,
2121        }
2122    }
2123}
2124
2125impl<'a, S> LogAddReactionBuilder<'a, S>
2126where
2127    S: log_add_reaction_state::State,
2128    S::ConvoId: log_add_reaction_state::IsUnset,
2129{
2130    /// Set the `convoId` field (required)
2131    pub fn convo_id(
2132        mut self,
2133        value: impl Into<CowStr<'a>>,
2134    ) -> LogAddReactionBuilder<'a, log_add_reaction_state::SetConvoId<S>> {
2135        self._fields.0 = Option::Some(value.into());
2136        LogAddReactionBuilder {
2137            _state: PhantomData,
2138            _fields: self._fields,
2139            _lifetime: PhantomData,
2140        }
2141    }
2142}
2143
2144impl<'a, S> LogAddReactionBuilder<'a, S>
2145where
2146    S: log_add_reaction_state::State,
2147    S::Message: log_add_reaction_state::IsUnset,
2148{
2149    /// Set the `message` field (required)
2150    pub fn message(
2151        mut self,
2152        value: impl Into<LogAddReactionMessage<'a>>,
2153    ) -> LogAddReactionBuilder<'a, log_add_reaction_state::SetMessage<S>> {
2154        self._fields.1 = Option::Some(value.into());
2155        LogAddReactionBuilder {
2156            _state: PhantomData,
2157            _fields: self._fields,
2158            _lifetime: PhantomData,
2159        }
2160    }
2161}
2162
2163impl<'a, S> LogAddReactionBuilder<'a, S>
2164where
2165    S: log_add_reaction_state::State,
2166    S::Reaction: log_add_reaction_state::IsUnset,
2167{
2168    /// Set the `reaction` field (required)
2169    pub fn reaction(
2170        mut self,
2171        value: impl Into<convo::ReactionView<'a>>,
2172    ) -> LogAddReactionBuilder<'a, log_add_reaction_state::SetReaction<S>> {
2173        self._fields.2 = Option::Some(value.into());
2174        LogAddReactionBuilder {
2175            _state: PhantomData,
2176            _fields: self._fields,
2177            _lifetime: PhantomData,
2178        }
2179    }
2180}
2181
2182impl<'a, S> LogAddReactionBuilder<'a, S>
2183where
2184    S: log_add_reaction_state::State,
2185    S::Rev: log_add_reaction_state::IsUnset,
2186{
2187    /// Set the `rev` field (required)
2188    pub fn rev(
2189        mut self,
2190        value: impl Into<CowStr<'a>>,
2191    ) -> LogAddReactionBuilder<'a, log_add_reaction_state::SetRev<S>> {
2192        self._fields.3 = Option::Some(value.into());
2193        LogAddReactionBuilder {
2194            _state: PhantomData,
2195            _fields: self._fields,
2196            _lifetime: PhantomData,
2197        }
2198    }
2199}
2200
2201impl<'a, S> LogAddReactionBuilder<'a, S>
2202where
2203    S: log_add_reaction_state::State,
2204    S::Reaction: log_add_reaction_state::IsSet,
2205    S::Rev: log_add_reaction_state::IsSet,
2206    S::ConvoId: log_add_reaction_state::IsSet,
2207    S::Message: log_add_reaction_state::IsSet,
2208{
2209    /// Build the final struct
2210    pub fn build(self) -> LogAddReaction<'a> {
2211        LogAddReaction {
2212            convo_id: self._fields.0.unwrap(),
2213            message: self._fields.1.unwrap(),
2214            reaction: self._fields.2.unwrap(),
2215            rev: self._fields.3.unwrap(),
2216            extra_data: Default::default(),
2217        }
2218    }
2219    /// Build the final struct with custom extra_data
2220    pub fn build_with_data(
2221        self,
2222        extra_data: BTreeMap<
2223            jacquard_common::deps::smol_str::SmolStr,
2224            jacquard_common::types::value::Data<'a>,
2225        >,
2226    ) -> LogAddReaction<'a> {
2227        LogAddReaction {
2228            convo_id: self._fields.0.unwrap(),
2229            message: self._fields.1.unwrap(),
2230            reaction: self._fields.2.unwrap(),
2231            rev: self._fields.3.unwrap(),
2232            extra_data: Some(extra_data),
2233        }
2234    }
2235}
2236
2237pub mod log_create_message_state {
2238
2239    pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
2240    #[allow(unused)]
2241    use ::core::marker::PhantomData;
2242    mod sealed {
2243        pub trait Sealed {}
2244    }
2245    /// State trait tracking which required fields have been set
2246    pub trait State: sealed::Sealed {
2247        type Message;
2248        type Rev;
2249        type ConvoId;
2250    }
2251    /// Empty state - all required fields are unset
2252    pub struct Empty(());
2253    impl sealed::Sealed for Empty {}
2254    impl State for Empty {
2255        type Message = Unset;
2256        type Rev = Unset;
2257        type ConvoId = Unset;
2258    }
2259    ///State transition - sets the `message` field to Set
2260    pub struct SetMessage<S: State = Empty>(PhantomData<fn() -> S>);
2261    impl<S: State> sealed::Sealed for SetMessage<S> {}
2262    impl<S: State> State for SetMessage<S> {
2263        type Message = Set<members::message>;
2264        type Rev = S::Rev;
2265        type ConvoId = S::ConvoId;
2266    }
2267    ///State transition - sets the `rev` field to Set
2268    pub struct SetRev<S: State = Empty>(PhantomData<fn() -> S>);
2269    impl<S: State> sealed::Sealed for SetRev<S> {}
2270    impl<S: State> State for SetRev<S> {
2271        type Message = S::Message;
2272        type Rev = Set<members::rev>;
2273        type ConvoId = S::ConvoId;
2274    }
2275    ///State transition - sets the `convo_id` field to Set
2276    pub struct SetConvoId<S: State = Empty>(PhantomData<fn() -> S>);
2277    impl<S: State> sealed::Sealed for SetConvoId<S> {}
2278    impl<S: State> State for SetConvoId<S> {
2279        type Message = S::Message;
2280        type Rev = S::Rev;
2281        type ConvoId = Set<members::convo_id>;
2282    }
2283    /// Marker types for field names
2284    #[allow(non_camel_case_types)]
2285    pub mod members {
2286        ///Marker type for the `message` field
2287        pub struct message(());
2288        ///Marker type for the `rev` field
2289        pub struct rev(());
2290        ///Marker type for the `convo_id` field
2291        pub struct convo_id(());
2292    }
2293}
2294
2295/// Builder for constructing an instance of this type
2296pub struct LogCreateMessageBuilder<'a, S: log_create_message_state::State> {
2297    _state: PhantomData<fn() -> S>,
2298    _fields: (
2299        Option<CowStr<'a>>,
2300        Option<LogCreateMessageMessage<'a>>,
2301        Option<CowStr<'a>>,
2302    ),
2303    _lifetime: PhantomData<&'a ()>,
2304}
2305
2306impl<'a> LogCreateMessage<'a> {
2307    /// Create a new builder for this type
2308    pub fn new() -> LogCreateMessageBuilder<'a, log_create_message_state::Empty> {
2309        LogCreateMessageBuilder::new()
2310    }
2311}
2312
2313impl<'a> LogCreateMessageBuilder<'a, log_create_message_state::Empty> {
2314    /// Create a new builder with all fields unset
2315    pub fn new() -> Self {
2316        LogCreateMessageBuilder {
2317            _state: PhantomData,
2318            _fields: (None, None, None),
2319            _lifetime: PhantomData,
2320        }
2321    }
2322}
2323
2324impl<'a, S> LogCreateMessageBuilder<'a, S>
2325where
2326    S: log_create_message_state::State,
2327    S::ConvoId: log_create_message_state::IsUnset,
2328{
2329    /// Set the `convoId` field (required)
2330    pub fn convo_id(
2331        mut self,
2332        value: impl Into<CowStr<'a>>,
2333    ) -> LogCreateMessageBuilder<'a, log_create_message_state::SetConvoId<S>> {
2334        self._fields.0 = Option::Some(value.into());
2335        LogCreateMessageBuilder {
2336            _state: PhantomData,
2337            _fields: self._fields,
2338            _lifetime: PhantomData,
2339        }
2340    }
2341}
2342
2343impl<'a, S> LogCreateMessageBuilder<'a, S>
2344where
2345    S: log_create_message_state::State,
2346    S::Message: log_create_message_state::IsUnset,
2347{
2348    /// Set the `message` field (required)
2349    pub fn message(
2350        mut self,
2351        value: impl Into<LogCreateMessageMessage<'a>>,
2352    ) -> LogCreateMessageBuilder<'a, log_create_message_state::SetMessage<S>> {
2353        self._fields.1 = Option::Some(value.into());
2354        LogCreateMessageBuilder {
2355            _state: PhantomData,
2356            _fields: self._fields,
2357            _lifetime: PhantomData,
2358        }
2359    }
2360}
2361
2362impl<'a, S> LogCreateMessageBuilder<'a, S>
2363where
2364    S: log_create_message_state::State,
2365    S::Rev: log_create_message_state::IsUnset,
2366{
2367    /// Set the `rev` field (required)
2368    pub fn rev(
2369        mut self,
2370        value: impl Into<CowStr<'a>>,
2371    ) -> LogCreateMessageBuilder<'a, log_create_message_state::SetRev<S>> {
2372        self._fields.2 = Option::Some(value.into());
2373        LogCreateMessageBuilder {
2374            _state: PhantomData,
2375            _fields: self._fields,
2376            _lifetime: PhantomData,
2377        }
2378    }
2379}
2380
2381impl<'a, S> LogCreateMessageBuilder<'a, S>
2382where
2383    S: log_create_message_state::State,
2384    S::Message: log_create_message_state::IsSet,
2385    S::Rev: log_create_message_state::IsSet,
2386    S::ConvoId: log_create_message_state::IsSet,
2387{
2388    /// Build the final struct
2389    pub fn build(self) -> LogCreateMessage<'a> {
2390        LogCreateMessage {
2391            convo_id: self._fields.0.unwrap(),
2392            message: self._fields.1.unwrap(),
2393            rev: self._fields.2.unwrap(),
2394            extra_data: Default::default(),
2395        }
2396    }
2397    /// Build the final struct with custom extra_data
2398    pub fn build_with_data(
2399        self,
2400        extra_data: BTreeMap<
2401            jacquard_common::deps::smol_str::SmolStr,
2402            jacquard_common::types::value::Data<'a>,
2403        >,
2404    ) -> LogCreateMessage<'a> {
2405        LogCreateMessage {
2406            convo_id: self._fields.0.unwrap(),
2407            message: self._fields.1.unwrap(),
2408            rev: self._fields.2.unwrap(),
2409            extra_data: Some(extra_data),
2410        }
2411    }
2412}
2413
2414pub mod log_delete_message_state {
2415
2416    pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
2417    #[allow(unused)]
2418    use ::core::marker::PhantomData;
2419    mod sealed {
2420        pub trait Sealed {}
2421    }
2422    /// State trait tracking which required fields have been set
2423    pub trait State: sealed::Sealed {
2424        type Message;
2425        type Rev;
2426        type ConvoId;
2427    }
2428    /// Empty state - all required fields are unset
2429    pub struct Empty(());
2430    impl sealed::Sealed for Empty {}
2431    impl State for Empty {
2432        type Message = Unset;
2433        type Rev = Unset;
2434        type ConvoId = Unset;
2435    }
2436    ///State transition - sets the `message` field to Set
2437    pub struct SetMessage<S: State = Empty>(PhantomData<fn() -> S>);
2438    impl<S: State> sealed::Sealed for SetMessage<S> {}
2439    impl<S: State> State for SetMessage<S> {
2440        type Message = Set<members::message>;
2441        type Rev = S::Rev;
2442        type ConvoId = S::ConvoId;
2443    }
2444    ///State transition - sets the `rev` field to Set
2445    pub struct SetRev<S: State = Empty>(PhantomData<fn() -> S>);
2446    impl<S: State> sealed::Sealed for SetRev<S> {}
2447    impl<S: State> State for SetRev<S> {
2448        type Message = S::Message;
2449        type Rev = Set<members::rev>;
2450        type ConvoId = S::ConvoId;
2451    }
2452    ///State transition - sets the `convo_id` field to Set
2453    pub struct SetConvoId<S: State = Empty>(PhantomData<fn() -> S>);
2454    impl<S: State> sealed::Sealed for SetConvoId<S> {}
2455    impl<S: State> State for SetConvoId<S> {
2456        type Message = S::Message;
2457        type Rev = S::Rev;
2458        type ConvoId = Set<members::convo_id>;
2459    }
2460    /// Marker types for field names
2461    #[allow(non_camel_case_types)]
2462    pub mod members {
2463        ///Marker type for the `message` field
2464        pub struct message(());
2465        ///Marker type for the `rev` field
2466        pub struct rev(());
2467        ///Marker type for the `convo_id` field
2468        pub struct convo_id(());
2469    }
2470}
2471
2472/// Builder for constructing an instance of this type
2473pub struct LogDeleteMessageBuilder<'a, S: log_delete_message_state::State> {
2474    _state: PhantomData<fn() -> S>,
2475    _fields: (
2476        Option<CowStr<'a>>,
2477        Option<LogDeleteMessageMessage<'a>>,
2478        Option<CowStr<'a>>,
2479    ),
2480    _lifetime: PhantomData<&'a ()>,
2481}
2482
2483impl<'a> LogDeleteMessage<'a> {
2484    /// Create a new builder for this type
2485    pub fn new() -> LogDeleteMessageBuilder<'a, log_delete_message_state::Empty> {
2486        LogDeleteMessageBuilder::new()
2487    }
2488}
2489
2490impl<'a> LogDeleteMessageBuilder<'a, log_delete_message_state::Empty> {
2491    /// Create a new builder with all fields unset
2492    pub fn new() -> Self {
2493        LogDeleteMessageBuilder {
2494            _state: PhantomData,
2495            _fields: (None, None, None),
2496            _lifetime: PhantomData,
2497        }
2498    }
2499}
2500
2501impl<'a, S> LogDeleteMessageBuilder<'a, S>
2502where
2503    S: log_delete_message_state::State,
2504    S::ConvoId: log_delete_message_state::IsUnset,
2505{
2506    /// Set the `convoId` field (required)
2507    pub fn convo_id(
2508        mut self,
2509        value: impl Into<CowStr<'a>>,
2510    ) -> LogDeleteMessageBuilder<'a, log_delete_message_state::SetConvoId<S>> {
2511        self._fields.0 = Option::Some(value.into());
2512        LogDeleteMessageBuilder {
2513            _state: PhantomData,
2514            _fields: self._fields,
2515            _lifetime: PhantomData,
2516        }
2517    }
2518}
2519
2520impl<'a, S> LogDeleteMessageBuilder<'a, S>
2521where
2522    S: log_delete_message_state::State,
2523    S::Message: log_delete_message_state::IsUnset,
2524{
2525    /// Set the `message` field (required)
2526    pub fn message(
2527        mut self,
2528        value: impl Into<LogDeleteMessageMessage<'a>>,
2529    ) -> LogDeleteMessageBuilder<'a, log_delete_message_state::SetMessage<S>> {
2530        self._fields.1 = Option::Some(value.into());
2531        LogDeleteMessageBuilder {
2532            _state: PhantomData,
2533            _fields: self._fields,
2534            _lifetime: PhantomData,
2535        }
2536    }
2537}
2538
2539impl<'a, S> LogDeleteMessageBuilder<'a, S>
2540where
2541    S: log_delete_message_state::State,
2542    S::Rev: log_delete_message_state::IsUnset,
2543{
2544    /// Set the `rev` field (required)
2545    pub fn rev(
2546        mut self,
2547        value: impl Into<CowStr<'a>>,
2548    ) -> LogDeleteMessageBuilder<'a, log_delete_message_state::SetRev<S>> {
2549        self._fields.2 = Option::Some(value.into());
2550        LogDeleteMessageBuilder {
2551            _state: PhantomData,
2552            _fields: self._fields,
2553            _lifetime: PhantomData,
2554        }
2555    }
2556}
2557
2558impl<'a, S> LogDeleteMessageBuilder<'a, S>
2559where
2560    S: log_delete_message_state::State,
2561    S::Message: log_delete_message_state::IsSet,
2562    S::Rev: log_delete_message_state::IsSet,
2563    S::ConvoId: log_delete_message_state::IsSet,
2564{
2565    /// Build the final struct
2566    pub fn build(self) -> LogDeleteMessage<'a> {
2567        LogDeleteMessage {
2568            convo_id: self._fields.0.unwrap(),
2569            message: self._fields.1.unwrap(),
2570            rev: self._fields.2.unwrap(),
2571            extra_data: Default::default(),
2572        }
2573    }
2574    /// Build the final struct with custom extra_data
2575    pub fn build_with_data(
2576        self,
2577        extra_data: BTreeMap<
2578            jacquard_common::deps::smol_str::SmolStr,
2579            jacquard_common::types::value::Data<'a>,
2580        >,
2581    ) -> LogDeleteMessage<'a> {
2582        LogDeleteMessage {
2583            convo_id: self._fields.0.unwrap(),
2584            message: self._fields.1.unwrap(),
2585            rev: self._fields.2.unwrap(),
2586            extra_data: Some(extra_data),
2587        }
2588    }
2589}
2590
2591pub mod log_read_message_state {
2592
2593    pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
2594    #[allow(unused)]
2595    use ::core::marker::PhantomData;
2596    mod sealed {
2597        pub trait Sealed {}
2598    }
2599    /// State trait tracking which required fields have been set
2600    pub trait State: sealed::Sealed {
2601        type Message;
2602        type Rev;
2603        type ConvoId;
2604    }
2605    /// Empty state - all required fields are unset
2606    pub struct Empty(());
2607    impl sealed::Sealed for Empty {}
2608    impl State for Empty {
2609        type Message = Unset;
2610        type Rev = Unset;
2611        type ConvoId = Unset;
2612    }
2613    ///State transition - sets the `message` field to Set
2614    pub struct SetMessage<S: State = Empty>(PhantomData<fn() -> S>);
2615    impl<S: State> sealed::Sealed for SetMessage<S> {}
2616    impl<S: State> State for SetMessage<S> {
2617        type Message = Set<members::message>;
2618        type Rev = S::Rev;
2619        type ConvoId = S::ConvoId;
2620    }
2621    ///State transition - sets the `rev` field to Set
2622    pub struct SetRev<S: State = Empty>(PhantomData<fn() -> S>);
2623    impl<S: State> sealed::Sealed for SetRev<S> {}
2624    impl<S: State> State for SetRev<S> {
2625        type Message = S::Message;
2626        type Rev = Set<members::rev>;
2627        type ConvoId = S::ConvoId;
2628    }
2629    ///State transition - sets the `convo_id` field to Set
2630    pub struct SetConvoId<S: State = Empty>(PhantomData<fn() -> S>);
2631    impl<S: State> sealed::Sealed for SetConvoId<S> {}
2632    impl<S: State> State for SetConvoId<S> {
2633        type Message = S::Message;
2634        type Rev = S::Rev;
2635        type ConvoId = Set<members::convo_id>;
2636    }
2637    /// Marker types for field names
2638    #[allow(non_camel_case_types)]
2639    pub mod members {
2640        ///Marker type for the `message` field
2641        pub struct message(());
2642        ///Marker type for the `rev` field
2643        pub struct rev(());
2644        ///Marker type for the `convo_id` field
2645        pub struct convo_id(());
2646    }
2647}
2648
2649/// Builder for constructing an instance of this type
2650pub struct LogReadMessageBuilder<'a, S: log_read_message_state::State> {
2651    _state: PhantomData<fn() -> S>,
2652    _fields: (Option<CowStr<'a>>, Option<LogReadMessageMessage<'a>>, Option<CowStr<'a>>),
2653    _lifetime: PhantomData<&'a ()>,
2654}
2655
2656impl<'a> LogReadMessage<'a> {
2657    /// Create a new builder for this type
2658    pub fn new() -> LogReadMessageBuilder<'a, log_read_message_state::Empty> {
2659        LogReadMessageBuilder::new()
2660    }
2661}
2662
2663impl<'a> LogReadMessageBuilder<'a, log_read_message_state::Empty> {
2664    /// Create a new builder with all fields unset
2665    pub fn new() -> Self {
2666        LogReadMessageBuilder {
2667            _state: PhantomData,
2668            _fields: (None, None, None),
2669            _lifetime: PhantomData,
2670        }
2671    }
2672}
2673
2674impl<'a, S> LogReadMessageBuilder<'a, S>
2675where
2676    S: log_read_message_state::State,
2677    S::ConvoId: log_read_message_state::IsUnset,
2678{
2679    /// Set the `convoId` field (required)
2680    pub fn convo_id(
2681        mut self,
2682        value: impl Into<CowStr<'a>>,
2683    ) -> LogReadMessageBuilder<'a, log_read_message_state::SetConvoId<S>> {
2684        self._fields.0 = Option::Some(value.into());
2685        LogReadMessageBuilder {
2686            _state: PhantomData,
2687            _fields: self._fields,
2688            _lifetime: PhantomData,
2689        }
2690    }
2691}
2692
2693impl<'a, S> LogReadMessageBuilder<'a, S>
2694where
2695    S: log_read_message_state::State,
2696    S::Message: log_read_message_state::IsUnset,
2697{
2698    /// Set the `message` field (required)
2699    pub fn message(
2700        mut self,
2701        value: impl Into<LogReadMessageMessage<'a>>,
2702    ) -> LogReadMessageBuilder<'a, log_read_message_state::SetMessage<S>> {
2703        self._fields.1 = Option::Some(value.into());
2704        LogReadMessageBuilder {
2705            _state: PhantomData,
2706            _fields: self._fields,
2707            _lifetime: PhantomData,
2708        }
2709    }
2710}
2711
2712impl<'a, S> LogReadMessageBuilder<'a, S>
2713where
2714    S: log_read_message_state::State,
2715    S::Rev: log_read_message_state::IsUnset,
2716{
2717    /// Set the `rev` field (required)
2718    pub fn rev(
2719        mut self,
2720        value: impl Into<CowStr<'a>>,
2721    ) -> LogReadMessageBuilder<'a, log_read_message_state::SetRev<S>> {
2722        self._fields.2 = Option::Some(value.into());
2723        LogReadMessageBuilder {
2724            _state: PhantomData,
2725            _fields: self._fields,
2726            _lifetime: PhantomData,
2727        }
2728    }
2729}
2730
2731impl<'a, S> LogReadMessageBuilder<'a, S>
2732where
2733    S: log_read_message_state::State,
2734    S::Message: log_read_message_state::IsSet,
2735    S::Rev: log_read_message_state::IsSet,
2736    S::ConvoId: log_read_message_state::IsSet,
2737{
2738    /// Build the final struct
2739    pub fn build(self) -> LogReadMessage<'a> {
2740        LogReadMessage {
2741            convo_id: self._fields.0.unwrap(),
2742            message: self._fields.1.unwrap(),
2743            rev: self._fields.2.unwrap(),
2744            extra_data: Default::default(),
2745        }
2746    }
2747    /// Build the final struct with custom extra_data
2748    pub fn build_with_data(
2749        self,
2750        extra_data: BTreeMap<
2751            jacquard_common::deps::smol_str::SmolStr,
2752            jacquard_common::types::value::Data<'a>,
2753        >,
2754    ) -> LogReadMessage<'a> {
2755        LogReadMessage {
2756            convo_id: self._fields.0.unwrap(),
2757            message: self._fields.1.unwrap(),
2758            rev: self._fields.2.unwrap(),
2759            extra_data: Some(extra_data),
2760        }
2761    }
2762}
2763
2764pub mod log_remove_reaction_state {
2765
2766    pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
2767    #[allow(unused)]
2768    use ::core::marker::PhantomData;
2769    mod sealed {
2770        pub trait Sealed {}
2771    }
2772    /// State trait tracking which required fields have been set
2773    pub trait State: sealed::Sealed {
2774        type ConvoId;
2775        type Rev;
2776        type Reaction;
2777        type Message;
2778    }
2779    /// Empty state - all required fields are unset
2780    pub struct Empty(());
2781    impl sealed::Sealed for Empty {}
2782    impl State for Empty {
2783        type ConvoId = Unset;
2784        type Rev = Unset;
2785        type Reaction = Unset;
2786        type Message = Unset;
2787    }
2788    ///State transition - sets the `convo_id` field to Set
2789    pub struct SetConvoId<S: State = Empty>(PhantomData<fn() -> S>);
2790    impl<S: State> sealed::Sealed for SetConvoId<S> {}
2791    impl<S: State> State for SetConvoId<S> {
2792        type ConvoId = Set<members::convo_id>;
2793        type Rev = S::Rev;
2794        type Reaction = S::Reaction;
2795        type Message = S::Message;
2796    }
2797    ///State transition - sets the `rev` field to Set
2798    pub struct SetRev<S: State = Empty>(PhantomData<fn() -> S>);
2799    impl<S: State> sealed::Sealed for SetRev<S> {}
2800    impl<S: State> State for SetRev<S> {
2801        type ConvoId = S::ConvoId;
2802        type Rev = Set<members::rev>;
2803        type Reaction = S::Reaction;
2804        type Message = S::Message;
2805    }
2806    ///State transition - sets the `reaction` field to Set
2807    pub struct SetReaction<S: State = Empty>(PhantomData<fn() -> S>);
2808    impl<S: State> sealed::Sealed for SetReaction<S> {}
2809    impl<S: State> State for SetReaction<S> {
2810        type ConvoId = S::ConvoId;
2811        type Rev = S::Rev;
2812        type Reaction = Set<members::reaction>;
2813        type Message = S::Message;
2814    }
2815    ///State transition - sets the `message` field to Set
2816    pub struct SetMessage<S: State = Empty>(PhantomData<fn() -> S>);
2817    impl<S: State> sealed::Sealed for SetMessage<S> {}
2818    impl<S: State> State for SetMessage<S> {
2819        type ConvoId = S::ConvoId;
2820        type Rev = S::Rev;
2821        type Reaction = S::Reaction;
2822        type Message = Set<members::message>;
2823    }
2824    /// Marker types for field names
2825    #[allow(non_camel_case_types)]
2826    pub mod members {
2827        ///Marker type for the `convo_id` field
2828        pub struct convo_id(());
2829        ///Marker type for the `rev` field
2830        pub struct rev(());
2831        ///Marker type for the `reaction` field
2832        pub struct reaction(());
2833        ///Marker type for the `message` field
2834        pub struct message(());
2835    }
2836}
2837
2838/// Builder for constructing an instance of this type
2839pub struct LogRemoveReactionBuilder<'a, S: log_remove_reaction_state::State> {
2840    _state: PhantomData<fn() -> S>,
2841    _fields: (
2842        Option<CowStr<'a>>,
2843        Option<LogRemoveReactionMessage<'a>>,
2844        Option<convo::ReactionView<'a>>,
2845        Option<CowStr<'a>>,
2846    ),
2847    _lifetime: PhantomData<&'a ()>,
2848}
2849
2850impl<'a> LogRemoveReaction<'a> {
2851    /// Create a new builder for this type
2852    pub fn new() -> LogRemoveReactionBuilder<'a, log_remove_reaction_state::Empty> {
2853        LogRemoveReactionBuilder::new()
2854    }
2855}
2856
2857impl<'a> LogRemoveReactionBuilder<'a, log_remove_reaction_state::Empty> {
2858    /// Create a new builder with all fields unset
2859    pub fn new() -> Self {
2860        LogRemoveReactionBuilder {
2861            _state: PhantomData,
2862            _fields: (None, None, None, None),
2863            _lifetime: PhantomData,
2864        }
2865    }
2866}
2867
2868impl<'a, S> LogRemoveReactionBuilder<'a, S>
2869where
2870    S: log_remove_reaction_state::State,
2871    S::ConvoId: log_remove_reaction_state::IsUnset,
2872{
2873    /// Set the `convoId` field (required)
2874    pub fn convo_id(
2875        mut self,
2876        value: impl Into<CowStr<'a>>,
2877    ) -> LogRemoveReactionBuilder<'a, log_remove_reaction_state::SetConvoId<S>> {
2878        self._fields.0 = Option::Some(value.into());
2879        LogRemoveReactionBuilder {
2880            _state: PhantomData,
2881            _fields: self._fields,
2882            _lifetime: PhantomData,
2883        }
2884    }
2885}
2886
2887impl<'a, S> LogRemoveReactionBuilder<'a, S>
2888where
2889    S: log_remove_reaction_state::State,
2890    S::Message: log_remove_reaction_state::IsUnset,
2891{
2892    /// Set the `message` field (required)
2893    pub fn message(
2894        mut self,
2895        value: impl Into<LogRemoveReactionMessage<'a>>,
2896    ) -> LogRemoveReactionBuilder<'a, log_remove_reaction_state::SetMessage<S>> {
2897        self._fields.1 = Option::Some(value.into());
2898        LogRemoveReactionBuilder {
2899            _state: PhantomData,
2900            _fields: self._fields,
2901            _lifetime: PhantomData,
2902        }
2903    }
2904}
2905
2906impl<'a, S> LogRemoveReactionBuilder<'a, S>
2907where
2908    S: log_remove_reaction_state::State,
2909    S::Reaction: log_remove_reaction_state::IsUnset,
2910{
2911    /// Set the `reaction` field (required)
2912    pub fn reaction(
2913        mut self,
2914        value: impl Into<convo::ReactionView<'a>>,
2915    ) -> LogRemoveReactionBuilder<'a, log_remove_reaction_state::SetReaction<S>> {
2916        self._fields.2 = Option::Some(value.into());
2917        LogRemoveReactionBuilder {
2918            _state: PhantomData,
2919            _fields: self._fields,
2920            _lifetime: PhantomData,
2921        }
2922    }
2923}
2924
2925impl<'a, S> LogRemoveReactionBuilder<'a, S>
2926where
2927    S: log_remove_reaction_state::State,
2928    S::Rev: log_remove_reaction_state::IsUnset,
2929{
2930    /// Set the `rev` field (required)
2931    pub fn rev(
2932        mut self,
2933        value: impl Into<CowStr<'a>>,
2934    ) -> LogRemoveReactionBuilder<'a, log_remove_reaction_state::SetRev<S>> {
2935        self._fields.3 = Option::Some(value.into());
2936        LogRemoveReactionBuilder {
2937            _state: PhantomData,
2938            _fields: self._fields,
2939            _lifetime: PhantomData,
2940        }
2941    }
2942}
2943
2944impl<'a, S> LogRemoveReactionBuilder<'a, S>
2945where
2946    S: log_remove_reaction_state::State,
2947    S::ConvoId: log_remove_reaction_state::IsSet,
2948    S::Rev: log_remove_reaction_state::IsSet,
2949    S::Reaction: log_remove_reaction_state::IsSet,
2950    S::Message: log_remove_reaction_state::IsSet,
2951{
2952    /// Build the final struct
2953    pub fn build(self) -> LogRemoveReaction<'a> {
2954        LogRemoveReaction {
2955            convo_id: self._fields.0.unwrap(),
2956            message: self._fields.1.unwrap(),
2957            reaction: self._fields.2.unwrap(),
2958            rev: self._fields.3.unwrap(),
2959            extra_data: Default::default(),
2960        }
2961    }
2962    /// Build the final struct with custom extra_data
2963    pub fn build_with_data(
2964        self,
2965        extra_data: BTreeMap<
2966            jacquard_common::deps::smol_str::SmolStr,
2967            jacquard_common::types::value::Data<'a>,
2968        >,
2969    ) -> LogRemoveReaction<'a> {
2970        LogRemoveReaction {
2971            convo_id: self._fields.0.unwrap(),
2972            message: self._fields.1.unwrap(),
2973            reaction: self._fields.2.unwrap(),
2974            rev: self._fields.3.unwrap(),
2975            extra_data: Some(extra_data),
2976        }
2977    }
2978}
2979
2980pub mod message_and_reaction_view_state {
2981
2982    pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
2983    #[allow(unused)]
2984    use ::core::marker::PhantomData;
2985    mod sealed {
2986        pub trait Sealed {}
2987    }
2988    /// State trait tracking which required fields have been set
2989    pub trait State: sealed::Sealed {
2990        type Message;
2991        type Reaction;
2992    }
2993    /// Empty state - all required fields are unset
2994    pub struct Empty(());
2995    impl sealed::Sealed for Empty {}
2996    impl State for Empty {
2997        type Message = Unset;
2998        type Reaction = Unset;
2999    }
3000    ///State transition - sets the `message` field to Set
3001    pub struct SetMessage<S: State = Empty>(PhantomData<fn() -> S>);
3002    impl<S: State> sealed::Sealed for SetMessage<S> {}
3003    impl<S: State> State for SetMessage<S> {
3004        type Message = Set<members::message>;
3005        type Reaction = S::Reaction;
3006    }
3007    ///State transition - sets the `reaction` field to Set
3008    pub struct SetReaction<S: State = Empty>(PhantomData<fn() -> S>);
3009    impl<S: State> sealed::Sealed for SetReaction<S> {}
3010    impl<S: State> State for SetReaction<S> {
3011        type Message = S::Message;
3012        type Reaction = Set<members::reaction>;
3013    }
3014    /// Marker types for field names
3015    #[allow(non_camel_case_types)]
3016    pub mod members {
3017        ///Marker type for the `message` field
3018        pub struct message(());
3019        ///Marker type for the `reaction` field
3020        pub struct reaction(());
3021    }
3022}
3023
3024/// Builder for constructing an instance of this type
3025pub struct MessageAndReactionViewBuilder<'a, S: message_and_reaction_view_state::State> {
3026    _state: PhantomData<fn() -> S>,
3027    _fields: (Option<convo::MessageView<'a>>, Option<convo::ReactionView<'a>>),
3028    _lifetime: PhantomData<&'a ()>,
3029}
3030
3031impl<'a> MessageAndReactionView<'a> {
3032    /// Create a new builder for this type
3033    pub fn new() -> MessageAndReactionViewBuilder<
3034        'a,
3035        message_and_reaction_view_state::Empty,
3036    > {
3037        MessageAndReactionViewBuilder::new()
3038    }
3039}
3040
3041impl<'a> MessageAndReactionViewBuilder<'a, message_and_reaction_view_state::Empty> {
3042    /// Create a new builder with all fields unset
3043    pub fn new() -> Self {
3044        MessageAndReactionViewBuilder {
3045            _state: PhantomData,
3046            _fields: (None, None),
3047            _lifetime: PhantomData,
3048        }
3049    }
3050}
3051
3052impl<'a, S> MessageAndReactionViewBuilder<'a, S>
3053where
3054    S: message_and_reaction_view_state::State,
3055    S::Message: message_and_reaction_view_state::IsUnset,
3056{
3057    /// Set the `message` field (required)
3058    pub fn message(
3059        mut self,
3060        value: impl Into<convo::MessageView<'a>>,
3061    ) -> MessageAndReactionViewBuilder<
3062        'a,
3063        message_and_reaction_view_state::SetMessage<S>,
3064    > {
3065        self._fields.0 = Option::Some(value.into());
3066        MessageAndReactionViewBuilder {
3067            _state: PhantomData,
3068            _fields: self._fields,
3069            _lifetime: PhantomData,
3070        }
3071    }
3072}
3073
3074impl<'a, S> MessageAndReactionViewBuilder<'a, S>
3075where
3076    S: message_and_reaction_view_state::State,
3077    S::Reaction: message_and_reaction_view_state::IsUnset,
3078{
3079    /// Set the `reaction` field (required)
3080    pub fn reaction(
3081        mut self,
3082        value: impl Into<convo::ReactionView<'a>>,
3083    ) -> MessageAndReactionViewBuilder<
3084        'a,
3085        message_and_reaction_view_state::SetReaction<S>,
3086    > {
3087        self._fields.1 = Option::Some(value.into());
3088        MessageAndReactionViewBuilder {
3089            _state: PhantomData,
3090            _fields: self._fields,
3091            _lifetime: PhantomData,
3092        }
3093    }
3094}
3095
3096impl<'a, S> MessageAndReactionViewBuilder<'a, S>
3097where
3098    S: message_and_reaction_view_state::State,
3099    S::Message: message_and_reaction_view_state::IsSet,
3100    S::Reaction: message_and_reaction_view_state::IsSet,
3101{
3102    /// Build the final struct
3103    pub fn build(self) -> MessageAndReactionView<'a> {
3104        MessageAndReactionView {
3105            message: self._fields.0.unwrap(),
3106            reaction: self._fields.1.unwrap(),
3107            extra_data: Default::default(),
3108        }
3109    }
3110    /// Build the final struct with custom extra_data
3111    pub fn build_with_data(
3112        self,
3113        extra_data: BTreeMap<
3114            jacquard_common::deps::smol_str::SmolStr,
3115            jacquard_common::types::value::Data<'a>,
3116        >,
3117    ) -> MessageAndReactionView<'a> {
3118        MessageAndReactionView {
3119            message: self._fields.0.unwrap(),
3120            reaction: self._fields.1.unwrap(),
3121            extra_data: Some(extra_data),
3122        }
3123    }
3124}
3125
3126pub mod message_ref_state {
3127
3128    pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
3129    #[allow(unused)]
3130    use ::core::marker::PhantomData;
3131    mod sealed {
3132        pub trait Sealed {}
3133    }
3134    /// State trait tracking which required fields have been set
3135    pub trait State: sealed::Sealed {
3136        type MessageId;
3137        type Did;
3138        type ConvoId;
3139    }
3140    /// Empty state - all required fields are unset
3141    pub struct Empty(());
3142    impl sealed::Sealed for Empty {}
3143    impl State for Empty {
3144        type MessageId = Unset;
3145        type Did = Unset;
3146        type ConvoId = Unset;
3147    }
3148    ///State transition - sets the `message_id` field to Set
3149    pub struct SetMessageId<S: State = Empty>(PhantomData<fn() -> S>);
3150    impl<S: State> sealed::Sealed for SetMessageId<S> {}
3151    impl<S: State> State for SetMessageId<S> {
3152        type MessageId = Set<members::message_id>;
3153        type Did = S::Did;
3154        type ConvoId = S::ConvoId;
3155    }
3156    ///State transition - sets the `did` field to Set
3157    pub struct SetDid<S: State = Empty>(PhantomData<fn() -> S>);
3158    impl<S: State> sealed::Sealed for SetDid<S> {}
3159    impl<S: State> State for SetDid<S> {
3160        type MessageId = S::MessageId;
3161        type Did = Set<members::did>;
3162        type ConvoId = S::ConvoId;
3163    }
3164    ///State transition - sets the `convo_id` field to Set
3165    pub struct SetConvoId<S: State = Empty>(PhantomData<fn() -> S>);
3166    impl<S: State> sealed::Sealed for SetConvoId<S> {}
3167    impl<S: State> State for SetConvoId<S> {
3168        type MessageId = S::MessageId;
3169        type Did = S::Did;
3170        type ConvoId = Set<members::convo_id>;
3171    }
3172    /// Marker types for field names
3173    #[allow(non_camel_case_types)]
3174    pub mod members {
3175        ///Marker type for the `message_id` field
3176        pub struct message_id(());
3177        ///Marker type for the `did` field
3178        pub struct did(());
3179        ///Marker type for the `convo_id` field
3180        pub struct convo_id(());
3181    }
3182}
3183
3184/// Builder for constructing an instance of this type
3185pub struct MessageRefBuilder<'a, S: message_ref_state::State> {
3186    _state: PhantomData<fn() -> S>,
3187    _fields: (Option<CowStr<'a>>, Option<Did<'a>>, Option<CowStr<'a>>),
3188    _lifetime: PhantomData<&'a ()>,
3189}
3190
3191impl<'a> MessageRef<'a> {
3192    /// Create a new builder for this type
3193    pub fn new() -> MessageRefBuilder<'a, message_ref_state::Empty> {
3194        MessageRefBuilder::new()
3195    }
3196}
3197
3198impl<'a> MessageRefBuilder<'a, message_ref_state::Empty> {
3199    /// Create a new builder with all fields unset
3200    pub fn new() -> Self {
3201        MessageRefBuilder {
3202            _state: PhantomData,
3203            _fields: (None, None, None),
3204            _lifetime: PhantomData,
3205        }
3206    }
3207}
3208
3209impl<'a, S> MessageRefBuilder<'a, S>
3210where
3211    S: message_ref_state::State,
3212    S::ConvoId: message_ref_state::IsUnset,
3213{
3214    /// Set the `convoId` field (required)
3215    pub fn convo_id(
3216        mut self,
3217        value: impl Into<CowStr<'a>>,
3218    ) -> MessageRefBuilder<'a, message_ref_state::SetConvoId<S>> {
3219        self._fields.0 = Option::Some(value.into());
3220        MessageRefBuilder {
3221            _state: PhantomData,
3222            _fields: self._fields,
3223            _lifetime: PhantomData,
3224        }
3225    }
3226}
3227
3228impl<'a, S> MessageRefBuilder<'a, S>
3229where
3230    S: message_ref_state::State,
3231    S::Did: message_ref_state::IsUnset,
3232{
3233    /// Set the `did` field (required)
3234    pub fn did(
3235        mut self,
3236        value: impl Into<Did<'a>>,
3237    ) -> MessageRefBuilder<'a, message_ref_state::SetDid<S>> {
3238        self._fields.1 = Option::Some(value.into());
3239        MessageRefBuilder {
3240            _state: PhantomData,
3241            _fields: self._fields,
3242            _lifetime: PhantomData,
3243        }
3244    }
3245}
3246
3247impl<'a, S> MessageRefBuilder<'a, S>
3248where
3249    S: message_ref_state::State,
3250    S::MessageId: message_ref_state::IsUnset,
3251{
3252    /// Set the `messageId` field (required)
3253    pub fn message_id(
3254        mut self,
3255        value: impl Into<CowStr<'a>>,
3256    ) -> MessageRefBuilder<'a, message_ref_state::SetMessageId<S>> {
3257        self._fields.2 = Option::Some(value.into());
3258        MessageRefBuilder {
3259            _state: PhantomData,
3260            _fields: self._fields,
3261            _lifetime: PhantomData,
3262        }
3263    }
3264}
3265
3266impl<'a, S> MessageRefBuilder<'a, S>
3267where
3268    S: message_ref_state::State,
3269    S::MessageId: message_ref_state::IsSet,
3270    S::Did: message_ref_state::IsSet,
3271    S::ConvoId: message_ref_state::IsSet,
3272{
3273    /// Build the final struct
3274    pub fn build(self) -> MessageRef<'a> {
3275        MessageRef {
3276            convo_id: self._fields.0.unwrap(),
3277            did: self._fields.1.unwrap(),
3278            message_id: self._fields.2.unwrap(),
3279            extra_data: Default::default(),
3280        }
3281    }
3282    /// Build the final struct with custom extra_data
3283    pub fn build_with_data(
3284        self,
3285        extra_data: BTreeMap<
3286            jacquard_common::deps::smol_str::SmolStr,
3287            jacquard_common::types::value::Data<'a>,
3288        >,
3289    ) -> MessageRef<'a> {
3290        MessageRef {
3291            convo_id: self._fields.0.unwrap(),
3292            did: self._fields.1.unwrap(),
3293            message_id: self._fields.2.unwrap(),
3294            extra_data: Some(extra_data),
3295        }
3296    }
3297}
3298
3299pub mod message_view_state {
3300
3301    pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
3302    #[allow(unused)]
3303    use ::core::marker::PhantomData;
3304    mod sealed {
3305        pub trait Sealed {}
3306    }
3307    /// State trait tracking which required fields have been set
3308    pub trait State: sealed::Sealed {
3309        type Id;
3310        type Rev;
3311        type SentAt;
3312        type Sender;
3313        type Text;
3314    }
3315    /// Empty state - all required fields are unset
3316    pub struct Empty(());
3317    impl sealed::Sealed for Empty {}
3318    impl State for Empty {
3319        type Id = Unset;
3320        type Rev = Unset;
3321        type SentAt = Unset;
3322        type Sender = Unset;
3323        type Text = Unset;
3324    }
3325    ///State transition - sets the `id` field to Set
3326    pub struct SetId<S: State = Empty>(PhantomData<fn() -> S>);
3327    impl<S: State> sealed::Sealed for SetId<S> {}
3328    impl<S: State> State for SetId<S> {
3329        type Id = Set<members::id>;
3330        type Rev = S::Rev;
3331        type SentAt = S::SentAt;
3332        type Sender = S::Sender;
3333        type Text = S::Text;
3334    }
3335    ///State transition - sets the `rev` field to Set
3336    pub struct SetRev<S: State = Empty>(PhantomData<fn() -> S>);
3337    impl<S: State> sealed::Sealed for SetRev<S> {}
3338    impl<S: State> State for SetRev<S> {
3339        type Id = S::Id;
3340        type Rev = Set<members::rev>;
3341        type SentAt = S::SentAt;
3342        type Sender = S::Sender;
3343        type Text = S::Text;
3344    }
3345    ///State transition - sets the `sent_at` field to Set
3346    pub struct SetSentAt<S: State = Empty>(PhantomData<fn() -> S>);
3347    impl<S: State> sealed::Sealed for SetSentAt<S> {}
3348    impl<S: State> State for SetSentAt<S> {
3349        type Id = S::Id;
3350        type Rev = S::Rev;
3351        type SentAt = Set<members::sent_at>;
3352        type Sender = S::Sender;
3353        type Text = S::Text;
3354    }
3355    ///State transition - sets the `sender` field to Set
3356    pub struct SetSender<S: State = Empty>(PhantomData<fn() -> S>);
3357    impl<S: State> sealed::Sealed for SetSender<S> {}
3358    impl<S: State> State for SetSender<S> {
3359        type Id = S::Id;
3360        type Rev = S::Rev;
3361        type SentAt = S::SentAt;
3362        type Sender = Set<members::sender>;
3363        type Text = S::Text;
3364    }
3365    ///State transition - sets the `text` field to Set
3366    pub struct SetText<S: State = Empty>(PhantomData<fn() -> S>);
3367    impl<S: State> sealed::Sealed for SetText<S> {}
3368    impl<S: State> State for SetText<S> {
3369        type Id = S::Id;
3370        type Rev = S::Rev;
3371        type SentAt = S::SentAt;
3372        type Sender = S::Sender;
3373        type Text = Set<members::text>;
3374    }
3375    /// Marker types for field names
3376    #[allow(non_camel_case_types)]
3377    pub mod members {
3378        ///Marker type for the `id` field
3379        pub struct id(());
3380        ///Marker type for the `rev` field
3381        pub struct rev(());
3382        ///Marker type for the `sent_at` field
3383        pub struct sent_at(());
3384        ///Marker type for the `sender` field
3385        pub struct sender(());
3386        ///Marker type for the `text` field
3387        pub struct text(());
3388    }
3389}
3390
3391/// Builder for constructing an instance of this type
3392pub struct MessageViewBuilder<'a, S: message_view_state::State> {
3393    _state: PhantomData<fn() -> S>,
3394    _fields: (
3395        Option<View<'a>>,
3396        Option<Vec<Facet<'a>>>,
3397        Option<CowStr<'a>>,
3398        Option<Vec<convo::ReactionView<'a>>>,
3399        Option<CowStr<'a>>,
3400        Option<convo::MessageViewSender<'a>>,
3401        Option<Datetime>,
3402        Option<CowStr<'a>>,
3403    ),
3404    _lifetime: PhantomData<&'a ()>,
3405}
3406
3407impl<'a> MessageView<'a> {
3408    /// Create a new builder for this type
3409    pub fn new() -> MessageViewBuilder<'a, message_view_state::Empty> {
3410        MessageViewBuilder::new()
3411    }
3412}
3413
3414impl<'a> MessageViewBuilder<'a, message_view_state::Empty> {
3415    /// Create a new builder with all fields unset
3416    pub fn new() -> Self {
3417        MessageViewBuilder {
3418            _state: PhantomData,
3419            _fields: (None, None, None, None, None, None, None, None),
3420            _lifetime: PhantomData,
3421        }
3422    }
3423}
3424
3425impl<'a, S: message_view_state::State> MessageViewBuilder<'a, S> {
3426    /// Set the `embed` field (optional)
3427    pub fn embed(mut self, value: impl Into<Option<View<'a>>>) -> Self {
3428        self._fields.0 = value.into();
3429        self
3430    }
3431    /// Set the `embed` field to an Option value (optional)
3432    pub fn maybe_embed(mut self, value: Option<View<'a>>) -> Self {
3433        self._fields.0 = value;
3434        self
3435    }
3436}
3437
3438impl<'a, S: message_view_state::State> MessageViewBuilder<'a, S> {
3439    /// Set the `facets` field (optional)
3440    pub fn facets(mut self, value: impl Into<Option<Vec<Facet<'a>>>>) -> Self {
3441        self._fields.1 = value.into();
3442        self
3443    }
3444    /// Set the `facets` field to an Option value (optional)
3445    pub fn maybe_facets(mut self, value: Option<Vec<Facet<'a>>>) -> Self {
3446        self._fields.1 = value;
3447        self
3448    }
3449}
3450
3451impl<'a, S> MessageViewBuilder<'a, S>
3452where
3453    S: message_view_state::State,
3454    S::Id: message_view_state::IsUnset,
3455{
3456    /// Set the `id` field (required)
3457    pub fn id(
3458        mut self,
3459        value: impl Into<CowStr<'a>>,
3460    ) -> MessageViewBuilder<'a, message_view_state::SetId<S>> {
3461        self._fields.2 = Option::Some(value.into());
3462        MessageViewBuilder {
3463            _state: PhantomData,
3464            _fields: self._fields,
3465            _lifetime: PhantomData,
3466        }
3467    }
3468}
3469
3470impl<'a, S: message_view_state::State> MessageViewBuilder<'a, S> {
3471    /// Set the `reactions` field (optional)
3472    pub fn reactions(
3473        mut self,
3474        value: impl Into<Option<Vec<convo::ReactionView<'a>>>>,
3475    ) -> Self {
3476        self._fields.3 = value.into();
3477        self
3478    }
3479    /// Set the `reactions` field to an Option value (optional)
3480    pub fn maybe_reactions(
3481        mut self,
3482        value: Option<Vec<convo::ReactionView<'a>>>,
3483    ) -> Self {
3484        self._fields.3 = value;
3485        self
3486    }
3487}
3488
3489impl<'a, S> MessageViewBuilder<'a, S>
3490where
3491    S: message_view_state::State,
3492    S::Rev: message_view_state::IsUnset,
3493{
3494    /// Set the `rev` field (required)
3495    pub fn rev(
3496        mut self,
3497        value: impl Into<CowStr<'a>>,
3498    ) -> MessageViewBuilder<'a, message_view_state::SetRev<S>> {
3499        self._fields.4 = Option::Some(value.into());
3500        MessageViewBuilder {
3501            _state: PhantomData,
3502            _fields: self._fields,
3503            _lifetime: PhantomData,
3504        }
3505    }
3506}
3507
3508impl<'a, S> MessageViewBuilder<'a, S>
3509where
3510    S: message_view_state::State,
3511    S::Sender: message_view_state::IsUnset,
3512{
3513    /// Set the `sender` field (required)
3514    pub fn sender(
3515        mut self,
3516        value: impl Into<convo::MessageViewSender<'a>>,
3517    ) -> MessageViewBuilder<'a, message_view_state::SetSender<S>> {
3518        self._fields.5 = Option::Some(value.into());
3519        MessageViewBuilder {
3520            _state: PhantomData,
3521            _fields: self._fields,
3522            _lifetime: PhantomData,
3523        }
3524    }
3525}
3526
3527impl<'a, S> MessageViewBuilder<'a, S>
3528where
3529    S: message_view_state::State,
3530    S::SentAt: message_view_state::IsUnset,
3531{
3532    /// Set the `sentAt` field (required)
3533    pub fn sent_at(
3534        mut self,
3535        value: impl Into<Datetime>,
3536    ) -> MessageViewBuilder<'a, message_view_state::SetSentAt<S>> {
3537        self._fields.6 = Option::Some(value.into());
3538        MessageViewBuilder {
3539            _state: PhantomData,
3540            _fields: self._fields,
3541            _lifetime: PhantomData,
3542        }
3543    }
3544}
3545
3546impl<'a, S> MessageViewBuilder<'a, S>
3547where
3548    S: message_view_state::State,
3549    S::Text: message_view_state::IsUnset,
3550{
3551    /// Set the `text` field (required)
3552    pub fn text(
3553        mut self,
3554        value: impl Into<CowStr<'a>>,
3555    ) -> MessageViewBuilder<'a, message_view_state::SetText<S>> {
3556        self._fields.7 = Option::Some(value.into());
3557        MessageViewBuilder {
3558            _state: PhantomData,
3559            _fields: self._fields,
3560            _lifetime: PhantomData,
3561        }
3562    }
3563}
3564
3565impl<'a, S> MessageViewBuilder<'a, S>
3566where
3567    S: message_view_state::State,
3568    S::Id: message_view_state::IsSet,
3569    S::Rev: message_view_state::IsSet,
3570    S::SentAt: message_view_state::IsSet,
3571    S::Sender: message_view_state::IsSet,
3572    S::Text: message_view_state::IsSet,
3573{
3574    /// Build the final struct
3575    pub fn build(self) -> MessageView<'a> {
3576        MessageView {
3577            embed: self._fields.0,
3578            facets: self._fields.1,
3579            id: self._fields.2.unwrap(),
3580            reactions: self._fields.3,
3581            rev: self._fields.4.unwrap(),
3582            sender: self._fields.5.unwrap(),
3583            sent_at: self._fields.6.unwrap(),
3584            text: self._fields.7.unwrap(),
3585            extra_data: Default::default(),
3586        }
3587    }
3588    /// Build the final struct with custom extra_data
3589    pub fn build_with_data(
3590        self,
3591        extra_data: BTreeMap<
3592            jacquard_common::deps::smol_str::SmolStr,
3593            jacquard_common::types::value::Data<'a>,
3594        >,
3595    ) -> MessageView<'a> {
3596        MessageView {
3597            embed: self._fields.0,
3598            facets: self._fields.1,
3599            id: self._fields.2.unwrap(),
3600            reactions: self._fields.3,
3601            rev: self._fields.4.unwrap(),
3602            sender: self._fields.5.unwrap(),
3603            sent_at: self._fields.6.unwrap(),
3604            text: self._fields.7.unwrap(),
3605            extra_data: Some(extra_data),
3606        }
3607    }
3608}
3609
3610pub mod message_view_sender_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    /// State trait tracking which required fields have been set
3619    pub trait State: sealed::Sealed {
3620        type Did;
3621    }
3622    /// Empty state - all required fields are unset
3623    pub struct Empty(());
3624    impl sealed::Sealed for Empty {}
3625    impl State for Empty {
3626        type Did = Unset;
3627    }
3628    ///State transition - sets the `did` field to Set
3629    pub struct SetDid<S: State = Empty>(PhantomData<fn() -> S>);
3630    impl<S: State> sealed::Sealed for SetDid<S> {}
3631    impl<S: State> State for SetDid<S> {
3632        type Did = Set<members::did>;
3633    }
3634    /// Marker types for field names
3635    #[allow(non_camel_case_types)]
3636    pub mod members {
3637        ///Marker type for the `did` field
3638        pub struct did(());
3639    }
3640}
3641
3642/// Builder for constructing an instance of this type
3643pub struct MessageViewSenderBuilder<'a, S: message_view_sender_state::State> {
3644    _state: PhantomData<fn() -> S>,
3645    _fields: (Option<Did<'a>>,),
3646    _lifetime: PhantomData<&'a ()>,
3647}
3648
3649impl<'a> MessageViewSender<'a> {
3650    /// Create a new builder for this type
3651    pub fn new() -> MessageViewSenderBuilder<'a, message_view_sender_state::Empty> {
3652        MessageViewSenderBuilder::new()
3653    }
3654}
3655
3656impl<'a> MessageViewSenderBuilder<'a, message_view_sender_state::Empty> {
3657    /// Create a new builder with all fields unset
3658    pub fn new() -> Self {
3659        MessageViewSenderBuilder {
3660            _state: PhantomData,
3661            _fields: (None,),
3662            _lifetime: PhantomData,
3663        }
3664    }
3665}
3666
3667impl<'a, S> MessageViewSenderBuilder<'a, S>
3668where
3669    S: message_view_sender_state::State,
3670    S::Did: message_view_sender_state::IsUnset,
3671{
3672    /// Set the `did` field (required)
3673    pub fn did(
3674        mut self,
3675        value: impl Into<Did<'a>>,
3676    ) -> MessageViewSenderBuilder<'a, message_view_sender_state::SetDid<S>> {
3677        self._fields.0 = Option::Some(value.into());
3678        MessageViewSenderBuilder {
3679            _state: PhantomData,
3680            _fields: self._fields,
3681            _lifetime: PhantomData,
3682        }
3683    }
3684}
3685
3686impl<'a, S> MessageViewSenderBuilder<'a, S>
3687where
3688    S: message_view_sender_state::State,
3689    S::Did: message_view_sender_state::IsSet,
3690{
3691    /// Build the final struct
3692    pub fn build(self) -> MessageViewSender<'a> {
3693        MessageViewSender {
3694            did: self._fields.0.unwrap(),
3695            extra_data: Default::default(),
3696        }
3697    }
3698    /// Build the final struct with custom extra_data
3699    pub fn build_with_data(
3700        self,
3701        extra_data: BTreeMap<
3702            jacquard_common::deps::smol_str::SmolStr,
3703            jacquard_common::types::value::Data<'a>,
3704        >,
3705    ) -> MessageViewSender<'a> {
3706        MessageViewSender {
3707            did: self._fields.0.unwrap(),
3708            extra_data: Some(extra_data),
3709        }
3710    }
3711}
3712
3713pub mod reaction_view_state {
3714
3715    pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
3716    #[allow(unused)]
3717    use ::core::marker::PhantomData;
3718    mod sealed {
3719        pub trait Sealed {}
3720    }
3721    /// State trait tracking which required fields have been set
3722    pub trait State: sealed::Sealed {
3723        type Value;
3724        type Sender;
3725        type CreatedAt;
3726    }
3727    /// Empty state - all required fields are unset
3728    pub struct Empty(());
3729    impl sealed::Sealed for Empty {}
3730    impl State for Empty {
3731        type Value = Unset;
3732        type Sender = Unset;
3733        type CreatedAt = Unset;
3734    }
3735    ///State transition - sets the `value` field to Set
3736    pub struct SetValue<S: State = Empty>(PhantomData<fn() -> S>);
3737    impl<S: State> sealed::Sealed for SetValue<S> {}
3738    impl<S: State> State for SetValue<S> {
3739        type Value = Set<members::value>;
3740        type Sender = S::Sender;
3741        type CreatedAt = S::CreatedAt;
3742    }
3743    ///State transition - sets the `sender` field to Set
3744    pub struct SetSender<S: State = Empty>(PhantomData<fn() -> S>);
3745    impl<S: State> sealed::Sealed for SetSender<S> {}
3746    impl<S: State> State for SetSender<S> {
3747        type Value = S::Value;
3748        type Sender = Set<members::sender>;
3749        type CreatedAt = S::CreatedAt;
3750    }
3751    ///State transition - sets the `created_at` field to Set
3752    pub struct SetCreatedAt<S: State = Empty>(PhantomData<fn() -> S>);
3753    impl<S: State> sealed::Sealed for SetCreatedAt<S> {}
3754    impl<S: State> State for SetCreatedAt<S> {
3755        type Value = S::Value;
3756        type Sender = S::Sender;
3757        type CreatedAt = Set<members::created_at>;
3758    }
3759    /// Marker types for field names
3760    #[allow(non_camel_case_types)]
3761    pub mod members {
3762        ///Marker type for the `value` field
3763        pub struct value(());
3764        ///Marker type for the `sender` field
3765        pub struct sender(());
3766        ///Marker type for the `created_at` field
3767        pub struct created_at(());
3768    }
3769}
3770
3771/// Builder for constructing an instance of this type
3772pub struct ReactionViewBuilder<'a, S: reaction_view_state::State> {
3773    _state: PhantomData<fn() -> S>,
3774    _fields: (
3775        Option<Datetime>,
3776        Option<convo::ReactionViewSender<'a>>,
3777        Option<CowStr<'a>>,
3778    ),
3779    _lifetime: PhantomData<&'a ()>,
3780}
3781
3782impl<'a> ReactionView<'a> {
3783    /// Create a new builder for this type
3784    pub fn new() -> ReactionViewBuilder<'a, reaction_view_state::Empty> {
3785        ReactionViewBuilder::new()
3786    }
3787}
3788
3789impl<'a> ReactionViewBuilder<'a, reaction_view_state::Empty> {
3790    /// Create a new builder with all fields unset
3791    pub fn new() -> Self {
3792        ReactionViewBuilder {
3793            _state: PhantomData,
3794            _fields: (None, None, None),
3795            _lifetime: PhantomData,
3796        }
3797    }
3798}
3799
3800impl<'a, S> ReactionViewBuilder<'a, S>
3801where
3802    S: reaction_view_state::State,
3803    S::CreatedAt: reaction_view_state::IsUnset,
3804{
3805    /// Set the `createdAt` field (required)
3806    pub fn created_at(
3807        mut self,
3808        value: impl Into<Datetime>,
3809    ) -> ReactionViewBuilder<'a, reaction_view_state::SetCreatedAt<S>> {
3810        self._fields.0 = Option::Some(value.into());
3811        ReactionViewBuilder {
3812            _state: PhantomData,
3813            _fields: self._fields,
3814            _lifetime: PhantomData,
3815        }
3816    }
3817}
3818
3819impl<'a, S> ReactionViewBuilder<'a, S>
3820where
3821    S: reaction_view_state::State,
3822    S::Sender: reaction_view_state::IsUnset,
3823{
3824    /// Set the `sender` field (required)
3825    pub fn sender(
3826        mut self,
3827        value: impl Into<convo::ReactionViewSender<'a>>,
3828    ) -> ReactionViewBuilder<'a, reaction_view_state::SetSender<S>> {
3829        self._fields.1 = Option::Some(value.into());
3830        ReactionViewBuilder {
3831            _state: PhantomData,
3832            _fields: self._fields,
3833            _lifetime: PhantomData,
3834        }
3835    }
3836}
3837
3838impl<'a, S> ReactionViewBuilder<'a, S>
3839where
3840    S: reaction_view_state::State,
3841    S::Value: reaction_view_state::IsUnset,
3842{
3843    /// Set the `value` field (required)
3844    pub fn value(
3845        mut self,
3846        value: impl Into<CowStr<'a>>,
3847    ) -> ReactionViewBuilder<'a, reaction_view_state::SetValue<S>> {
3848        self._fields.2 = Option::Some(value.into());
3849        ReactionViewBuilder {
3850            _state: PhantomData,
3851            _fields: self._fields,
3852            _lifetime: PhantomData,
3853        }
3854    }
3855}
3856
3857impl<'a, S> ReactionViewBuilder<'a, S>
3858where
3859    S: reaction_view_state::State,
3860    S::Value: reaction_view_state::IsSet,
3861    S::Sender: reaction_view_state::IsSet,
3862    S::CreatedAt: reaction_view_state::IsSet,
3863{
3864    /// Build the final struct
3865    pub fn build(self) -> ReactionView<'a> {
3866        ReactionView {
3867            created_at: self._fields.0.unwrap(),
3868            sender: self._fields.1.unwrap(),
3869            value: self._fields.2.unwrap(),
3870            extra_data: Default::default(),
3871        }
3872    }
3873    /// Build the final struct with custom extra_data
3874    pub fn build_with_data(
3875        self,
3876        extra_data: BTreeMap<
3877            jacquard_common::deps::smol_str::SmolStr,
3878            jacquard_common::types::value::Data<'a>,
3879        >,
3880    ) -> ReactionView<'a> {
3881        ReactionView {
3882            created_at: self._fields.0.unwrap(),
3883            sender: self._fields.1.unwrap(),
3884            value: self._fields.2.unwrap(),
3885            extra_data: Some(extra_data),
3886        }
3887    }
3888}
3889
3890pub mod reaction_view_sender_state {
3891
3892    pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
3893    #[allow(unused)]
3894    use ::core::marker::PhantomData;
3895    mod sealed {
3896        pub trait Sealed {}
3897    }
3898    /// State trait tracking which required fields have been set
3899    pub trait State: sealed::Sealed {
3900        type Did;
3901    }
3902    /// Empty state - all required fields are unset
3903    pub struct Empty(());
3904    impl sealed::Sealed for Empty {}
3905    impl State for Empty {
3906        type Did = Unset;
3907    }
3908    ///State transition - sets the `did` field to Set
3909    pub struct SetDid<S: State = Empty>(PhantomData<fn() -> S>);
3910    impl<S: State> sealed::Sealed for SetDid<S> {}
3911    impl<S: State> State for SetDid<S> {
3912        type Did = Set<members::did>;
3913    }
3914    /// Marker types for field names
3915    #[allow(non_camel_case_types)]
3916    pub mod members {
3917        ///Marker type for the `did` field
3918        pub struct did(());
3919    }
3920}
3921
3922/// Builder for constructing an instance of this type
3923pub struct ReactionViewSenderBuilder<'a, S: reaction_view_sender_state::State> {
3924    _state: PhantomData<fn() -> S>,
3925    _fields: (Option<Did<'a>>,),
3926    _lifetime: PhantomData<&'a ()>,
3927}
3928
3929impl<'a> ReactionViewSender<'a> {
3930    /// Create a new builder for this type
3931    pub fn new() -> ReactionViewSenderBuilder<'a, reaction_view_sender_state::Empty> {
3932        ReactionViewSenderBuilder::new()
3933    }
3934}
3935
3936impl<'a> ReactionViewSenderBuilder<'a, reaction_view_sender_state::Empty> {
3937    /// Create a new builder with all fields unset
3938    pub fn new() -> Self {
3939        ReactionViewSenderBuilder {
3940            _state: PhantomData,
3941            _fields: (None,),
3942            _lifetime: PhantomData,
3943        }
3944    }
3945}
3946
3947impl<'a, S> ReactionViewSenderBuilder<'a, S>
3948where
3949    S: reaction_view_sender_state::State,
3950    S::Did: reaction_view_sender_state::IsUnset,
3951{
3952    /// Set the `did` field (required)
3953    pub fn did(
3954        mut self,
3955        value: impl Into<Did<'a>>,
3956    ) -> ReactionViewSenderBuilder<'a, reaction_view_sender_state::SetDid<S>> {
3957        self._fields.0 = Option::Some(value.into());
3958        ReactionViewSenderBuilder {
3959            _state: PhantomData,
3960            _fields: self._fields,
3961            _lifetime: PhantomData,
3962        }
3963    }
3964}
3965
3966impl<'a, S> ReactionViewSenderBuilder<'a, S>
3967where
3968    S: reaction_view_sender_state::State,
3969    S::Did: reaction_view_sender_state::IsSet,
3970{
3971    /// Build the final struct
3972    pub fn build(self) -> ReactionViewSender<'a> {
3973        ReactionViewSender {
3974            did: self._fields.0.unwrap(),
3975            extra_data: Default::default(),
3976        }
3977    }
3978    /// Build the final struct with custom extra_data
3979    pub fn build_with_data(
3980        self,
3981        extra_data: BTreeMap<
3982            jacquard_common::deps::smol_str::SmolStr,
3983            jacquard_common::types::value::Data<'a>,
3984        >,
3985    ) -> ReactionViewSender<'a> {
3986        ReactionViewSender {
3987            did: self._fields.0.unwrap(),
3988            extra_data: Some(extra_data),
3989        }
3990    }
3991}
jacquard_api/chat_bsky/convo.rs

jacquard_api/chat_bsky/
convo.rs
