jacquard_api/app_bsky/embed/
record.rs

1// @generated by jacquard-lexicon. DO NOT EDIT.
2//
3// Lexicon: app.bsky.embed.record
4//
5// This file was automatically generated from Lexicon schemas.
6// Any manual changes will be overwritten on the next regeneration.
7
8#[jacquard_derive::lexicon]
9#[derive(
10    serde::Serialize,
11    serde::Deserialize,
12    Debug,
13    Clone,
14    PartialEq,
15    Eq,
16    jacquard_derive::IntoStatic
17)]
18#[serde(rename_all = "camelCase")]
19pub struct Record<'a> {
20    #[serde(borrow)]
21    pub record: crate::com_atproto::repo::strong_ref::StrongRef<'a>,
22}
23
24pub mod record_state {
25
26    pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
27    #[allow(unused)]
28    use ::core::marker::PhantomData;
29    mod sealed {
30        pub trait Sealed {}
31    }
32    /// State trait tracking which required fields have been set
33    pub trait State: sealed::Sealed {
34        type Record;
35    }
36    /// Empty state - all required fields are unset
37    pub struct Empty(());
38    impl sealed::Sealed for Empty {}
39    impl State for Empty {
40        type Record = Unset;
41    }
42    ///State transition - sets the `record` field to Set
43    pub struct SetRecord<S: State = Empty>(PhantomData<fn() -> S>);
44    impl<S: State> sealed::Sealed for SetRecord<S> {}
45    impl<S: State> State for SetRecord<S> {
46        type Record = Set<members::record>;
47    }
48    /// Marker types for field names
49    #[allow(non_camel_case_types)]
50    pub mod members {
51        ///Marker type for the `record` field
52        pub struct record(());
53    }
54}
55
56/// Builder for constructing an instance of this type
57pub struct RecordBuilder<'a, S: record_state::State> {
58    _phantom_state: ::core::marker::PhantomData<fn() -> S>,
59    __unsafe_private_named: (
60        ::core::option::Option<crate::com_atproto::repo::strong_ref::StrongRef<'a>>,
61    ),
62    _phantom: ::core::marker::PhantomData<&'a ()>,
63}
64
65impl<'a> Record<'a> {
66    /// Create a new builder for this type
67    pub fn new() -> RecordBuilder<'a, record_state::Empty> {
68        RecordBuilder::new()
69    }
70}
71
72impl<'a> RecordBuilder<'a, record_state::Empty> {
73    /// Create a new builder with all fields unset
74    pub fn new() -> Self {
75        RecordBuilder {
76            _phantom_state: ::core::marker::PhantomData,
77            __unsafe_private_named: (None,),
78            _phantom: ::core::marker::PhantomData,
79        }
80    }
81}
82
83impl<'a, S> RecordBuilder<'a, S>
84where
85    S: record_state::State,
86    S::Record: record_state::IsUnset,
87{
88    /// Set the `record` field (required)
89    pub fn record(
90        mut self,
91        value: impl Into<crate::com_atproto::repo::strong_ref::StrongRef<'a>>,
92    ) -> RecordBuilder<'a, record_state::SetRecord<S>> {
93        self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
94        RecordBuilder {
95            _phantom_state: ::core::marker::PhantomData,
96            __unsafe_private_named: self.__unsafe_private_named,
97            _phantom: ::core::marker::PhantomData,
98        }
99    }
100}
101
102impl<'a, S> RecordBuilder<'a, S>
103where
104    S: record_state::State,
105    S::Record: record_state::IsSet,
106{
107    /// Build the final struct
108    pub fn build(self) -> Record<'a> {
109        Record {
110            record: self.__unsafe_private_named.0.unwrap(),
111            extra_data: Default::default(),
112        }
113    }
114    /// Build the final struct with custom extra_data
115    pub fn build_with_data(
116        self,
117        extra_data: std::collections::BTreeMap<
118            jacquard_common::smol_str::SmolStr,
119            jacquard_common::types::value::Data<'a>,
120        >,
121    ) -> Record<'a> {
122        Record {
123            record: self.__unsafe_private_named.0.unwrap(),
124            extra_data: Some(extra_data),
125        }
126    }
127}
128
129fn lexicon_doc_app_bsky_embed_record() -> ::jacquard_lexicon::lexicon::LexiconDoc<
130    'static,
131> {
132    ::jacquard_lexicon::lexicon::LexiconDoc {
133        lexicon: ::jacquard_lexicon::lexicon::Lexicon::Lexicon1,
134        id: ::jacquard_common::CowStr::new_static("app.bsky.embed.record"),
135        revision: None,
136        description: None,
137        defs: {
138            let mut map = ::std::collections::BTreeMap::new();
139            map.insert(
140                ::jacquard_common::smol_str::SmolStr::new_static("main"),
141                ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
142                    description: None,
143                    required: Some(
144                        vec![::jacquard_common::smol_str::SmolStr::new_static("record")],
145                    ),
146                    nullable: None,
147                    properties: {
148                        #[allow(unused_mut)]
149                        let mut map = ::std::collections::BTreeMap::new();
150                        map.insert(
151                            ::jacquard_common::smol_str::SmolStr::new_static("record"),
152                            ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
153                                description: None,
154                                r#ref: ::jacquard_common::CowStr::new_static(
155                                    "com.atproto.repo.strongRef",
156                                ),
157                            }),
158                        );
159                        map
160                    },
161                }),
162            );
163            map.insert(
164                ::jacquard_common::smol_str::SmolStr::new_static("view"),
165                ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
166                    description: None,
167                    required: Some(
168                        vec![::jacquard_common::smol_str::SmolStr::new_static("record")],
169                    ),
170                    nullable: None,
171                    properties: {
172                        #[allow(unused_mut)]
173                        let mut map = ::std::collections::BTreeMap::new();
174                        map.insert(
175                            ::jacquard_common::smol_str::SmolStr::new_static("record"),
176                            ::jacquard_lexicon::lexicon::LexObjectProperty::Union(::jacquard_lexicon::lexicon::LexRefUnion {
177                                description: None,
178                                refs: vec![
179                                    ::jacquard_common::CowStr::new_static("#viewRecord"),
180                                    ::jacquard_common::CowStr::new_static("#viewNotFound"),
181                                    ::jacquard_common::CowStr::new_static("#viewBlocked"),
182                                    ::jacquard_common::CowStr::new_static("#viewDetached"),
183                                    ::jacquard_common::CowStr::new_static("app.bsky.feed.defs#generatorView"),
184                                    ::jacquard_common::CowStr::new_static("app.bsky.graph.defs#listView"),
185                                    ::jacquard_common::CowStr::new_static("app.bsky.labeler.defs#labelerView"),
186                                    ::jacquard_common::CowStr::new_static("app.bsky.graph.defs#starterPackViewBasic")
187                                ],
188                                closed: None,
189                            }),
190                        );
191                        map
192                    },
193                }),
194            );
195            map.insert(
196                ::jacquard_common::smol_str::SmolStr::new_static("viewBlocked"),
197                ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
198                    description: None,
199                    required: Some(
200                        vec![
201                            ::jacquard_common::smol_str::SmolStr::new_static("uri"),
202                            ::jacquard_common::smol_str::SmolStr::new_static("blocked"),
203                            ::jacquard_common::smol_str::SmolStr::new_static("author")
204                        ],
205                    ),
206                    nullable: None,
207                    properties: {
208                        #[allow(unused_mut)]
209                        let mut map = ::std::collections::BTreeMap::new();
210                        map.insert(
211                            ::jacquard_common::smol_str::SmolStr::new_static("author"),
212                            ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
213                                description: None,
214                                r#ref: ::jacquard_common::CowStr::new_static(
215                                    "app.bsky.feed.defs#blockedAuthor",
216                                ),
217                            }),
218                        );
219                        map.insert(
220                            ::jacquard_common::smol_str::SmolStr::new_static("blocked"),
221                            ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
222                                description: None,
223                                default: None,
224                                r#const: None,
225                            }),
226                        );
227                        map.insert(
228                            ::jacquard_common::smol_str::SmolStr::new_static("uri"),
229                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
230                                description: None,
231                                format: Some(
232                                    ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
233                                ),
234                                default: None,
235                                min_length: None,
236                                max_length: None,
237                                min_graphemes: None,
238                                max_graphemes: None,
239                                r#enum: None,
240                                r#const: None,
241                                known_values: None,
242                            }),
243                        );
244                        map
245                    },
246                }),
247            );
248            map.insert(
249                ::jacquard_common::smol_str::SmolStr::new_static("viewDetached"),
250                ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
251                    description: None,
252                    required: Some(
253                        vec![
254                            ::jacquard_common::smol_str::SmolStr::new_static("uri"),
255                            ::jacquard_common::smol_str::SmolStr::new_static("detached")
256                        ],
257                    ),
258                    nullable: None,
259                    properties: {
260                        #[allow(unused_mut)]
261                        let mut map = ::std::collections::BTreeMap::new();
262                        map.insert(
263                            ::jacquard_common::smol_str::SmolStr::new_static("detached"),
264                            ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
265                                description: None,
266                                default: None,
267                                r#const: None,
268                            }),
269                        );
270                        map.insert(
271                            ::jacquard_common::smol_str::SmolStr::new_static("uri"),
272                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
273                                description: None,
274                                format: Some(
275                                    ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
276                                ),
277                                default: None,
278                                min_length: None,
279                                max_length: None,
280                                min_graphemes: None,
281                                max_graphemes: None,
282                                r#enum: None,
283                                r#const: None,
284                                known_values: None,
285                            }),
286                        );
287                        map
288                    },
289                }),
290            );
291            map.insert(
292                ::jacquard_common::smol_str::SmolStr::new_static("viewNotFound"),
293                ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
294                    description: None,
295                    required: Some(
296                        vec![
297                            ::jacquard_common::smol_str::SmolStr::new_static("uri"),
298                            ::jacquard_common::smol_str::SmolStr::new_static("notFound")
299                        ],
300                    ),
301                    nullable: None,
302                    properties: {
303                        #[allow(unused_mut)]
304                        let mut map = ::std::collections::BTreeMap::new();
305                        map.insert(
306                            ::jacquard_common::smol_str::SmolStr::new_static("notFound"),
307                            ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
308                                description: None,
309                                default: None,
310                                r#const: None,
311                            }),
312                        );
313                        map.insert(
314                            ::jacquard_common::smol_str::SmolStr::new_static("uri"),
315                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
316                                description: None,
317                                format: Some(
318                                    ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
319                                ),
320                                default: None,
321                                min_length: None,
322                                max_length: None,
323                                min_graphemes: None,
324                                max_graphemes: None,
325                                r#enum: None,
326                                r#const: None,
327                                known_values: None,
328                            }),
329                        );
330                        map
331                    },
332                }),
333            );
334            map.insert(
335                ::jacquard_common::smol_str::SmolStr::new_static("viewRecord"),
336                ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
337                    description: None,
338                    required: Some(
339                        vec![
340                            ::jacquard_common::smol_str::SmolStr::new_static("uri"),
341                            ::jacquard_common::smol_str::SmolStr::new_static("cid"),
342                            ::jacquard_common::smol_str::SmolStr::new_static("author"),
343                            ::jacquard_common::smol_str::SmolStr::new_static("value"),
344                            ::jacquard_common::smol_str::SmolStr::new_static("indexedAt")
345                        ],
346                    ),
347                    nullable: None,
348                    properties: {
349                        #[allow(unused_mut)]
350                        let mut map = ::std::collections::BTreeMap::new();
351                        map.insert(
352                            ::jacquard_common::smol_str::SmolStr::new_static("author"),
353                            ::jacquard_lexicon::lexicon::LexObjectProperty::Ref(::jacquard_lexicon::lexicon::LexRef {
354                                description: None,
355                                r#ref: ::jacquard_common::CowStr::new_static(
356                                    "app.bsky.actor.defs#profileViewBasic",
357                                ),
358                            }),
359                        );
360                        map.insert(
361                            ::jacquard_common::smol_str::SmolStr::new_static("cid"),
362                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
363                                description: None,
364                                format: Some(
365                                    ::jacquard_lexicon::lexicon::LexStringFormat::Cid,
366                                ),
367                                default: None,
368                                min_length: None,
369                                max_length: None,
370                                min_graphemes: None,
371                                max_graphemes: None,
372                                r#enum: None,
373                                r#const: None,
374                                known_values: None,
375                            }),
376                        );
377                        map.insert(
378                            ::jacquard_common::smol_str::SmolStr::new_static("embeds"),
379                            ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
380                                description: None,
381                                items: ::jacquard_lexicon::lexicon::LexArrayItem::Union(::jacquard_lexicon::lexicon::LexRefUnion {
382                                    description: None,
383                                    refs: vec![
384                                        ::jacquard_common::CowStr::new_static("app.bsky.embed.images#view"),
385                                        ::jacquard_common::CowStr::new_static("app.bsky.embed.video#view"),
386                                        ::jacquard_common::CowStr::new_static("app.bsky.embed.external#view"),
387                                        ::jacquard_common::CowStr::new_static("app.bsky.embed.record#view"),
388                                        ::jacquard_common::CowStr::new_static("app.bsky.embed.recordWithMedia#view")
389                                    ],
390                                    closed: None,
391                                }),
392                                min_length: None,
393                                max_length: None,
394                            }),
395                        );
396                        map.insert(
397                            ::jacquard_common::smol_str::SmolStr::new_static(
398                                "indexedAt",
399                            ),
400                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
401                                description: None,
402                                format: Some(
403                                    ::jacquard_lexicon::lexicon::LexStringFormat::Datetime,
404                                ),
405                                default: None,
406                                min_length: None,
407                                max_length: None,
408                                min_graphemes: None,
409                                max_graphemes: None,
410                                r#enum: None,
411                                r#const: None,
412                                known_values: None,
413                            }),
414                        );
415                        map.insert(
416                            ::jacquard_common::smol_str::SmolStr::new_static("labels"),
417                            ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
418                                description: None,
419                                items: ::jacquard_lexicon::lexicon::LexArrayItem::Ref(::jacquard_lexicon::lexicon::LexRef {
420                                    description: None,
421                                    r#ref: ::jacquard_common::CowStr::new_static(
422                                        "com.atproto.label.defs#label",
423                                    ),
424                                }),
425                                min_length: None,
426                                max_length: None,
427                            }),
428                        );
429                        map.insert(
430                            ::jacquard_common::smol_str::SmolStr::new_static(
431                                "likeCount",
432                            ),
433                            ::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger {
434                                description: None,
435                                default: None,
436                                minimum: None,
437                                maximum: None,
438                                r#enum: None,
439                                r#const: None,
440                            }),
441                        );
442                        map.insert(
443                            ::jacquard_common::smol_str::SmolStr::new_static(
444                                "quoteCount",
445                            ),
446                            ::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger {
447                                description: None,
448                                default: None,
449                                minimum: None,
450                                maximum: None,
451                                r#enum: None,
452                                r#const: None,
453                            }),
454                        );
455                        map.insert(
456                            ::jacquard_common::smol_str::SmolStr::new_static(
457                                "replyCount",
458                            ),
459                            ::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger {
460                                description: None,
461                                default: None,
462                                minimum: None,
463                                maximum: None,
464                                r#enum: None,
465                                r#const: None,
466                            }),
467                        );
468                        map.insert(
469                            ::jacquard_common::smol_str::SmolStr::new_static(
470                                "repostCount",
471                            ),
472                            ::jacquard_lexicon::lexicon::LexObjectProperty::Integer(::jacquard_lexicon::lexicon::LexInteger {
473                                description: None,
474                                default: None,
475                                minimum: None,
476                                maximum: None,
477                                r#enum: None,
478                                r#const: None,
479                            }),
480                        );
481                        map.insert(
482                            ::jacquard_common::smol_str::SmolStr::new_static("uri"),
483                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
484                                description: None,
485                                format: Some(
486                                    ::jacquard_lexicon::lexicon::LexStringFormat::AtUri,
487                                ),
488                                default: None,
489                                min_length: None,
490                                max_length: None,
491                                min_graphemes: None,
492                                max_graphemes: None,
493                                r#enum: None,
494                                r#const: None,
495                                known_values: None,
496                            }),
497                        );
498                        map.insert(
499                            ::jacquard_common::smol_str::SmolStr::new_static("value"),
500                            ::jacquard_lexicon::lexicon::LexObjectProperty::Unknown(::jacquard_lexicon::lexicon::LexUnknown {
501                                description: None,
502                            }),
503                        );
504                        map
505                    },
506                }),
507            );
508            map
509        },
510    }
511}
512
513impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Record<'a> {
514    fn nsid() -> &'static str {
515        "app.bsky.embed.record"
516    }
517    fn def_name() -> &'static str {
518        "main"
519    }
520    fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
521        lexicon_doc_app_bsky_embed_record()
522    }
523    fn validate(
524        &self,
525    ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
526        Ok(())
527    }
528}
529
530#[jacquard_derive::lexicon]
531#[derive(
532    serde::Serialize,
533    serde::Deserialize,
534    Debug,
535    Clone,
536    PartialEq,
537    Eq,
538    jacquard_derive::IntoStatic
539)]
540#[serde(rename_all = "camelCase")]
541pub struct View<'a> {
542    #[serde(borrow)]
543    pub record: ViewUnionRecord<'a>,
544}
545
546pub mod view_state {
547
548    pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
549    #[allow(unused)]
550    use ::core::marker::PhantomData;
551    mod sealed {
552        pub trait Sealed {}
553    }
554    /// State trait tracking which required fields have been set
555    pub trait State: sealed::Sealed {
556        type Record;
557    }
558    /// Empty state - all required fields are unset
559    pub struct Empty(());
560    impl sealed::Sealed for Empty {}
561    impl State for Empty {
562        type Record = Unset;
563    }
564    ///State transition - sets the `record` field to Set
565    pub struct SetRecord<S: State = Empty>(PhantomData<fn() -> S>);
566    impl<S: State> sealed::Sealed for SetRecord<S> {}
567    impl<S: State> State for SetRecord<S> {
568        type Record = Set<members::record>;
569    }
570    /// Marker types for field names
571    #[allow(non_camel_case_types)]
572    pub mod members {
573        ///Marker type for the `record` field
574        pub struct record(());
575    }
576}
577
578/// Builder for constructing an instance of this type
579pub struct ViewBuilder<'a, S: view_state::State> {
580    _phantom_state: ::core::marker::PhantomData<fn() -> S>,
581    __unsafe_private_named: (::core::option::Option<ViewUnionRecord<'a>>,),
582    _phantom: ::core::marker::PhantomData<&'a ()>,
583}
584
585impl<'a> View<'a> {
586    /// Create a new builder for this type
587    pub fn new() -> ViewBuilder<'a, view_state::Empty> {
588        ViewBuilder::new()
589    }
590}
591
592impl<'a> ViewBuilder<'a, view_state::Empty> {
593    /// Create a new builder with all fields unset
594    pub fn new() -> Self {
595        ViewBuilder {
596            _phantom_state: ::core::marker::PhantomData,
597            __unsafe_private_named: (None,),
598            _phantom: ::core::marker::PhantomData,
599        }
600    }
601}
602
603impl<'a, S> ViewBuilder<'a, S>
604where
605    S: view_state::State,
606    S::Record: view_state::IsUnset,
607{
608    /// Set the `record` field (required)
609    pub fn record(
610        mut self,
611        value: impl Into<ViewUnionRecord<'a>>,
612    ) -> ViewBuilder<'a, view_state::SetRecord<S>> {
613        self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
614        ViewBuilder {
615            _phantom_state: ::core::marker::PhantomData,
616            __unsafe_private_named: self.__unsafe_private_named,
617            _phantom: ::core::marker::PhantomData,
618        }
619    }
620}
621
622impl<'a, S> ViewBuilder<'a, S>
623where
624    S: view_state::State,
625    S::Record: view_state::IsSet,
626{
627    /// Build the final struct
628    pub fn build(self) -> View<'a> {
629        View {
630            record: self.__unsafe_private_named.0.unwrap(),
631            extra_data: Default::default(),
632        }
633    }
634    /// Build the final struct with custom extra_data
635    pub fn build_with_data(
636        self,
637        extra_data: std::collections::BTreeMap<
638            jacquard_common::smol_str::SmolStr,
639            jacquard_common::types::value::Data<'a>,
640        >,
641    ) -> View<'a> {
642        View {
643            record: self.__unsafe_private_named.0.unwrap(),
644            extra_data: Some(extra_data),
645        }
646    }
647}
648
649#[jacquard_derive::open_union]
650#[derive(
651    serde::Serialize,
652    serde::Deserialize,
653    Debug,
654    Clone,
655    PartialEq,
656    Eq,
657    jacquard_derive::IntoStatic
658)]
659#[serde(tag = "$type")]
660#[serde(bound(deserialize = "'de: 'a"))]
661pub enum ViewUnionRecord<'a> {
662    #[serde(rename = "app.bsky.embed.record#viewRecord")]
663    ViewRecord(Box<crate::app_bsky::embed::record::ViewRecord<'a>>),
664    #[serde(rename = "app.bsky.embed.record#viewNotFound")]
665    ViewNotFound(Box<crate::app_bsky::embed::record::ViewNotFound<'a>>),
666    #[serde(rename = "app.bsky.embed.record#viewBlocked")]
667    ViewBlocked(Box<crate::app_bsky::embed::record::ViewBlocked<'a>>),
668    #[serde(rename = "app.bsky.embed.record#viewDetached")]
669    ViewDetached(Box<crate::app_bsky::embed::record::ViewDetached<'a>>),
670    #[serde(rename = "app.bsky.feed.defs#generatorView")]
671    GeneratorView(Box<crate::app_bsky::feed::GeneratorView<'a>>),
672    #[serde(rename = "app.bsky.graph.defs#listView")]
673    ListView(Box<crate::app_bsky::graph::ListView<'a>>),
674    #[serde(rename = "app.bsky.labeler.defs#labelerView")]
675    LabelerView(Box<crate::app_bsky::labeler::LabelerView<'a>>),
676    #[serde(rename = "app.bsky.graph.defs#starterPackViewBasic")]
677    StarterPackViewBasic(Box<crate::app_bsky::graph::StarterPackViewBasic<'a>>),
678}
679
680impl<'a> ::jacquard_lexicon::schema::LexiconSchema for View<'a> {
681    fn nsid() -> &'static str {
682        "app.bsky.embed.record"
683    }
684    fn def_name() -> &'static str {
685        "view"
686    }
687    fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
688        lexicon_doc_app_bsky_embed_record()
689    }
690    fn validate(
691        &self,
692    ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
693        Ok(())
694    }
695}
696
697#[jacquard_derive::lexicon]
698#[derive(
699    serde::Serialize,
700    serde::Deserialize,
701    Debug,
702    Clone,
703    PartialEq,
704    Eq,
705    jacquard_derive::IntoStatic
706)]
707#[serde(rename_all = "camelCase")]
708pub struct ViewBlocked<'a> {
709    #[serde(borrow)]
710    pub author: crate::app_bsky::feed::BlockedAuthor<'a>,
711    pub blocked: bool,
712    #[serde(borrow)]
713    pub uri: jacquard_common::types::string::AtUri<'a>,
714}
715
716pub mod view_blocked_state {
717
718    pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
719    #[allow(unused)]
720    use ::core::marker::PhantomData;
721    mod sealed {
722        pub trait Sealed {}
723    }
724    /// State trait tracking which required fields have been set
725    pub trait State: sealed::Sealed {
726        type Uri;
727        type Blocked;
728        type Author;
729    }
730    /// Empty state - all required fields are unset
731    pub struct Empty(());
732    impl sealed::Sealed for Empty {}
733    impl State for Empty {
734        type Uri = Unset;
735        type Blocked = Unset;
736        type Author = Unset;
737    }
738    ///State transition - sets the `uri` field to Set
739    pub struct SetUri<S: State = Empty>(PhantomData<fn() -> S>);
740    impl<S: State> sealed::Sealed for SetUri<S> {}
741    impl<S: State> State for SetUri<S> {
742        type Uri = Set<members::uri>;
743        type Blocked = S::Blocked;
744        type Author = S::Author;
745    }
746    ///State transition - sets the `blocked` field to Set
747    pub struct SetBlocked<S: State = Empty>(PhantomData<fn() -> S>);
748    impl<S: State> sealed::Sealed for SetBlocked<S> {}
749    impl<S: State> State for SetBlocked<S> {
750        type Uri = S::Uri;
751        type Blocked = Set<members::blocked>;
752        type Author = S::Author;
753    }
754    ///State transition - sets the `author` field to Set
755    pub struct SetAuthor<S: State = Empty>(PhantomData<fn() -> S>);
756    impl<S: State> sealed::Sealed for SetAuthor<S> {}
757    impl<S: State> State for SetAuthor<S> {
758        type Uri = S::Uri;
759        type Blocked = S::Blocked;
760        type Author = Set<members::author>;
761    }
762    /// Marker types for field names
763    #[allow(non_camel_case_types)]
764    pub mod members {
765        ///Marker type for the `uri` field
766        pub struct uri(());
767        ///Marker type for the `blocked` field
768        pub struct blocked(());
769        ///Marker type for the `author` field
770        pub struct author(());
771    }
772}
773
774/// Builder for constructing an instance of this type
775pub struct ViewBlockedBuilder<'a, S: view_blocked_state::State> {
776    _phantom_state: ::core::marker::PhantomData<fn() -> S>,
777    __unsafe_private_named: (
778        ::core::option::Option<crate::app_bsky::feed::BlockedAuthor<'a>>,
779        ::core::option::Option<bool>,
780        ::core::option::Option<jacquard_common::types::string::AtUri<'a>>,
781    ),
782    _phantom: ::core::marker::PhantomData<&'a ()>,
783}
784
785impl<'a> ViewBlocked<'a> {
786    /// Create a new builder for this type
787    pub fn new() -> ViewBlockedBuilder<'a, view_blocked_state::Empty> {
788        ViewBlockedBuilder::new()
789    }
790}
791
792impl<'a> ViewBlockedBuilder<'a, view_blocked_state::Empty> {
793    /// Create a new builder with all fields unset
794    pub fn new() -> Self {
795        ViewBlockedBuilder {
796            _phantom_state: ::core::marker::PhantomData,
797            __unsafe_private_named: (None, None, None),
798            _phantom: ::core::marker::PhantomData,
799        }
800    }
801}
802
803impl<'a, S> ViewBlockedBuilder<'a, S>
804where
805    S: view_blocked_state::State,
806    S::Author: view_blocked_state::IsUnset,
807{
808    /// Set the `author` field (required)
809    pub fn author(
810        mut self,
811        value: impl Into<crate::app_bsky::feed::BlockedAuthor<'a>>,
812    ) -> ViewBlockedBuilder<'a, view_blocked_state::SetAuthor<S>> {
813        self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
814        ViewBlockedBuilder {
815            _phantom_state: ::core::marker::PhantomData,
816            __unsafe_private_named: self.__unsafe_private_named,
817            _phantom: ::core::marker::PhantomData,
818        }
819    }
820}
821
822impl<'a, S> ViewBlockedBuilder<'a, S>
823where
824    S: view_blocked_state::State,
825    S::Blocked: view_blocked_state::IsUnset,
826{
827    /// Set the `blocked` field (required)
828    pub fn blocked(
829        mut self,
830        value: impl Into<bool>,
831    ) -> ViewBlockedBuilder<'a, view_blocked_state::SetBlocked<S>> {
832        self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
833        ViewBlockedBuilder {
834            _phantom_state: ::core::marker::PhantomData,
835            __unsafe_private_named: self.__unsafe_private_named,
836            _phantom: ::core::marker::PhantomData,
837        }
838    }
839}
840
841impl<'a, S> ViewBlockedBuilder<'a, S>
842where
843    S: view_blocked_state::State,
844    S::Uri: view_blocked_state::IsUnset,
845{
846    /// Set the `uri` field (required)
847    pub fn uri(
848        mut self,
849        value: impl Into<jacquard_common::types::string::AtUri<'a>>,
850    ) -> ViewBlockedBuilder<'a, view_blocked_state::SetUri<S>> {
851        self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into());
852        ViewBlockedBuilder {
853            _phantom_state: ::core::marker::PhantomData,
854            __unsafe_private_named: self.__unsafe_private_named,
855            _phantom: ::core::marker::PhantomData,
856        }
857    }
858}
859
860impl<'a, S> ViewBlockedBuilder<'a, S>
861where
862    S: view_blocked_state::State,
863    S::Uri: view_blocked_state::IsSet,
864    S::Blocked: view_blocked_state::IsSet,
865    S::Author: view_blocked_state::IsSet,
866{
867    /// Build the final struct
868    pub fn build(self) -> ViewBlocked<'a> {
869        ViewBlocked {
870            author: self.__unsafe_private_named.0.unwrap(),
871            blocked: self.__unsafe_private_named.1.unwrap(),
872            uri: self.__unsafe_private_named.2.unwrap(),
873            extra_data: Default::default(),
874        }
875    }
876    /// Build the final struct with custom extra_data
877    pub fn build_with_data(
878        self,
879        extra_data: std::collections::BTreeMap<
880            jacquard_common::smol_str::SmolStr,
881            jacquard_common::types::value::Data<'a>,
882        >,
883    ) -> ViewBlocked<'a> {
884        ViewBlocked {
885            author: self.__unsafe_private_named.0.unwrap(),
886            blocked: self.__unsafe_private_named.1.unwrap(),
887            uri: self.__unsafe_private_named.2.unwrap(),
888            extra_data: Some(extra_data),
889        }
890    }
891}
892
893impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ViewBlocked<'a> {
894    fn nsid() -> &'static str {
895        "app.bsky.embed.record"
896    }
897    fn def_name() -> &'static str {
898        "viewBlocked"
899    }
900    fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
901        lexicon_doc_app_bsky_embed_record()
902    }
903    fn validate(
904        &self,
905    ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
906        Ok(())
907    }
908}
909
910#[jacquard_derive::lexicon]
911#[derive(
912    serde::Serialize,
913    serde::Deserialize,
914    Debug,
915    Clone,
916    PartialEq,
917    Eq,
918    jacquard_derive::IntoStatic
919)]
920#[serde(rename_all = "camelCase")]
921pub struct ViewDetached<'a> {
922    pub detached: bool,
923    #[serde(borrow)]
924    pub uri: jacquard_common::types::string::AtUri<'a>,
925}
926
927pub mod view_detached_state {
928
929    pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
930    #[allow(unused)]
931    use ::core::marker::PhantomData;
932    mod sealed {
933        pub trait Sealed {}
934    }
935    /// State trait tracking which required fields have been set
936    pub trait State: sealed::Sealed {
937        type Uri;
938        type Detached;
939    }
940    /// Empty state - all required fields are unset
941    pub struct Empty(());
942    impl sealed::Sealed for Empty {}
943    impl State for Empty {
944        type Uri = Unset;
945        type Detached = Unset;
946    }
947    ///State transition - sets the `uri` field to Set
948    pub struct SetUri<S: State = Empty>(PhantomData<fn() -> S>);
949    impl<S: State> sealed::Sealed for SetUri<S> {}
950    impl<S: State> State for SetUri<S> {
951        type Uri = Set<members::uri>;
952        type Detached = S::Detached;
953    }
954    ///State transition - sets the `detached` field to Set
955    pub struct SetDetached<S: State = Empty>(PhantomData<fn() -> S>);
956    impl<S: State> sealed::Sealed for SetDetached<S> {}
957    impl<S: State> State for SetDetached<S> {
958        type Uri = S::Uri;
959        type Detached = Set<members::detached>;
960    }
961    /// Marker types for field names
962    #[allow(non_camel_case_types)]
963    pub mod members {
964        ///Marker type for the `uri` field
965        pub struct uri(());
966        ///Marker type for the `detached` field
967        pub struct detached(());
968    }
969}
970
971/// Builder for constructing an instance of this type
972pub struct ViewDetachedBuilder<'a, S: view_detached_state::State> {
973    _phantom_state: ::core::marker::PhantomData<fn() -> S>,
974    __unsafe_private_named: (
975        ::core::option::Option<bool>,
976        ::core::option::Option<jacquard_common::types::string::AtUri<'a>>,
977    ),
978    _phantom: ::core::marker::PhantomData<&'a ()>,
979}
980
981impl<'a> ViewDetached<'a> {
982    /// Create a new builder for this type
983    pub fn new() -> ViewDetachedBuilder<'a, view_detached_state::Empty> {
984        ViewDetachedBuilder::new()
985    }
986}
987
988impl<'a> ViewDetachedBuilder<'a, view_detached_state::Empty> {
989    /// Create a new builder with all fields unset
990    pub fn new() -> Self {
991        ViewDetachedBuilder {
992            _phantom_state: ::core::marker::PhantomData,
993            __unsafe_private_named: (None, None),
994            _phantom: ::core::marker::PhantomData,
995        }
996    }
997}
998
999impl<'a, S> ViewDetachedBuilder<'a, S>
1000where
1001    S: view_detached_state::State,
1002    S::Detached: view_detached_state::IsUnset,
1003{
1004    /// Set the `detached` field (required)
1005    pub fn detached(
1006        mut self,
1007        value: impl Into<bool>,
1008    ) -> ViewDetachedBuilder<'a, view_detached_state::SetDetached<S>> {
1009        self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
1010        ViewDetachedBuilder {
1011            _phantom_state: ::core::marker::PhantomData,
1012            __unsafe_private_named: self.__unsafe_private_named,
1013            _phantom: ::core::marker::PhantomData,
1014        }
1015    }
1016}
1017
1018impl<'a, S> ViewDetachedBuilder<'a, S>
1019where
1020    S: view_detached_state::State,
1021    S::Uri: view_detached_state::IsUnset,
1022{
1023    /// Set the `uri` field (required)
1024    pub fn uri(
1025        mut self,
1026        value: impl Into<jacquard_common::types::string::AtUri<'a>>,
1027    ) -> ViewDetachedBuilder<'a, view_detached_state::SetUri<S>> {
1028        self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
1029        ViewDetachedBuilder {
1030            _phantom_state: ::core::marker::PhantomData,
1031            __unsafe_private_named: self.__unsafe_private_named,
1032            _phantom: ::core::marker::PhantomData,
1033        }
1034    }
1035}
1036
1037impl<'a, S> ViewDetachedBuilder<'a, S>
1038where
1039    S: view_detached_state::State,
1040    S::Uri: view_detached_state::IsSet,
1041    S::Detached: view_detached_state::IsSet,
1042{
1043    /// Build the final struct
1044    pub fn build(self) -> ViewDetached<'a> {
1045        ViewDetached {
1046            detached: self.__unsafe_private_named.0.unwrap(),
1047            uri: self.__unsafe_private_named.1.unwrap(),
1048            extra_data: Default::default(),
1049        }
1050    }
1051    /// Build the final struct with custom extra_data
1052    pub fn build_with_data(
1053        self,
1054        extra_data: std::collections::BTreeMap<
1055            jacquard_common::smol_str::SmolStr,
1056            jacquard_common::types::value::Data<'a>,
1057        >,
1058    ) -> ViewDetached<'a> {
1059        ViewDetached {
1060            detached: self.__unsafe_private_named.0.unwrap(),
1061            uri: self.__unsafe_private_named.1.unwrap(),
1062            extra_data: Some(extra_data),
1063        }
1064    }
1065}
1066
1067impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ViewDetached<'a> {
1068    fn nsid() -> &'static str {
1069        "app.bsky.embed.record"
1070    }
1071    fn def_name() -> &'static str {
1072        "viewDetached"
1073    }
1074    fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
1075        lexicon_doc_app_bsky_embed_record()
1076    }
1077    fn validate(
1078        &self,
1079    ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
1080        Ok(())
1081    }
1082}
1083
1084#[jacquard_derive::lexicon]
1085#[derive(
1086    serde::Serialize,
1087    serde::Deserialize,
1088    Debug,
1089    Clone,
1090    PartialEq,
1091    Eq,
1092    jacquard_derive::IntoStatic
1093)]
1094#[serde(rename_all = "camelCase")]
1095pub struct ViewNotFound<'a> {
1096    pub not_found: bool,
1097    #[serde(borrow)]
1098    pub uri: jacquard_common::types::string::AtUri<'a>,
1099}
1100
1101pub mod view_not_found_state {
1102
1103    pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
1104    #[allow(unused)]
1105    use ::core::marker::PhantomData;
1106    mod sealed {
1107        pub trait Sealed {}
1108    }
1109    /// State trait tracking which required fields have been set
1110    pub trait State: sealed::Sealed {
1111        type Uri;
1112        type NotFound;
1113    }
1114    /// Empty state - all required fields are unset
1115    pub struct Empty(());
1116    impl sealed::Sealed for Empty {}
1117    impl State for Empty {
1118        type Uri = Unset;
1119        type NotFound = Unset;
1120    }
1121    ///State transition - sets the `uri` field to Set
1122    pub struct SetUri<S: State = Empty>(PhantomData<fn() -> S>);
1123    impl<S: State> sealed::Sealed for SetUri<S> {}
1124    impl<S: State> State for SetUri<S> {
1125        type Uri = Set<members::uri>;
1126        type NotFound = S::NotFound;
1127    }
1128    ///State transition - sets the `not_found` field to Set
1129    pub struct SetNotFound<S: State = Empty>(PhantomData<fn() -> S>);
1130    impl<S: State> sealed::Sealed for SetNotFound<S> {}
1131    impl<S: State> State for SetNotFound<S> {
1132        type Uri = S::Uri;
1133        type NotFound = Set<members::not_found>;
1134    }
1135    /// Marker types for field names
1136    #[allow(non_camel_case_types)]
1137    pub mod members {
1138        ///Marker type for the `uri` field
1139        pub struct uri(());
1140        ///Marker type for the `not_found` field
1141        pub struct not_found(());
1142    }
1143}
1144
1145/// Builder for constructing an instance of this type
1146pub struct ViewNotFoundBuilder<'a, S: view_not_found_state::State> {
1147    _phantom_state: ::core::marker::PhantomData<fn() -> S>,
1148    __unsafe_private_named: (
1149        ::core::option::Option<bool>,
1150        ::core::option::Option<jacquard_common::types::string::AtUri<'a>>,
1151    ),
1152    _phantom: ::core::marker::PhantomData<&'a ()>,
1153}
1154
1155impl<'a> ViewNotFound<'a> {
1156    /// Create a new builder for this type
1157    pub fn new() -> ViewNotFoundBuilder<'a, view_not_found_state::Empty> {
1158        ViewNotFoundBuilder::new()
1159    }
1160}
1161
1162impl<'a> ViewNotFoundBuilder<'a, view_not_found_state::Empty> {
1163    /// Create a new builder with all fields unset
1164    pub fn new() -> Self {
1165        ViewNotFoundBuilder {
1166            _phantom_state: ::core::marker::PhantomData,
1167            __unsafe_private_named: (None, None),
1168            _phantom: ::core::marker::PhantomData,
1169        }
1170    }
1171}
1172
1173impl<'a, S> ViewNotFoundBuilder<'a, S>
1174where
1175    S: view_not_found_state::State,
1176    S::NotFound: view_not_found_state::IsUnset,
1177{
1178    /// Set the `notFound` field (required)
1179    pub fn not_found(
1180        mut self,
1181        value: impl Into<bool>,
1182    ) -> ViewNotFoundBuilder<'a, view_not_found_state::SetNotFound<S>> {
1183        self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
1184        ViewNotFoundBuilder {
1185            _phantom_state: ::core::marker::PhantomData,
1186            __unsafe_private_named: self.__unsafe_private_named,
1187            _phantom: ::core::marker::PhantomData,
1188        }
1189    }
1190}
1191
1192impl<'a, S> ViewNotFoundBuilder<'a, S>
1193where
1194    S: view_not_found_state::State,
1195    S::Uri: view_not_found_state::IsUnset,
1196{
1197    /// Set the `uri` field (required)
1198    pub fn uri(
1199        mut self,
1200        value: impl Into<jacquard_common::types::string::AtUri<'a>>,
1201    ) -> ViewNotFoundBuilder<'a, view_not_found_state::SetUri<S>> {
1202        self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
1203        ViewNotFoundBuilder {
1204            _phantom_state: ::core::marker::PhantomData,
1205            __unsafe_private_named: self.__unsafe_private_named,
1206            _phantom: ::core::marker::PhantomData,
1207        }
1208    }
1209}
1210
1211impl<'a, S> ViewNotFoundBuilder<'a, S>
1212where
1213    S: view_not_found_state::State,
1214    S::Uri: view_not_found_state::IsSet,
1215    S::NotFound: view_not_found_state::IsSet,
1216{
1217    /// Build the final struct
1218    pub fn build(self) -> ViewNotFound<'a> {
1219        ViewNotFound {
1220            not_found: self.__unsafe_private_named.0.unwrap(),
1221            uri: self.__unsafe_private_named.1.unwrap(),
1222            extra_data: Default::default(),
1223        }
1224    }
1225    /// Build the final struct with custom extra_data
1226    pub fn build_with_data(
1227        self,
1228        extra_data: std::collections::BTreeMap<
1229            jacquard_common::smol_str::SmolStr,
1230            jacquard_common::types::value::Data<'a>,
1231        >,
1232    ) -> ViewNotFound<'a> {
1233        ViewNotFound {
1234            not_found: self.__unsafe_private_named.0.unwrap(),
1235            uri: self.__unsafe_private_named.1.unwrap(),
1236            extra_data: Some(extra_data),
1237        }
1238    }
1239}
1240
1241impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ViewNotFound<'a> {
1242    fn nsid() -> &'static str {
1243        "app.bsky.embed.record"
1244    }
1245    fn def_name() -> &'static str {
1246        "viewNotFound"
1247    }
1248    fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
1249        lexicon_doc_app_bsky_embed_record()
1250    }
1251    fn validate(
1252        &self,
1253    ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
1254        Ok(())
1255    }
1256}
1257
1258#[jacquard_derive::lexicon]
1259#[derive(
1260    serde::Serialize,
1261    serde::Deserialize,
1262    Debug,
1263    Clone,
1264    PartialEq,
1265    Eq,
1266    jacquard_derive::IntoStatic
1267)]
1268#[serde(rename_all = "camelCase")]
1269pub struct ViewRecord<'a> {
1270    #[serde(borrow)]
1271    pub author: crate::app_bsky::actor::ProfileViewBasic<'a>,
1272    #[serde(borrow)]
1273    pub cid: jacquard_common::types::string::Cid<'a>,
1274    #[serde(skip_serializing_if = "std::option::Option::is_none")]
1275    #[serde(borrow)]
1276    pub embeds: Option<Vec<ViewRecordEmbedsItem<'a>>>,
1277    pub indexed_at: jacquard_common::types::string::Datetime,
1278    #[serde(skip_serializing_if = "std::option::Option::is_none")]
1279    #[serde(borrow)]
1280    pub labels: Option<Vec<crate::com_atproto::label::Label<'a>>>,
1281    #[serde(skip_serializing_if = "std::option::Option::is_none")]
1282    pub like_count: Option<i64>,
1283    #[serde(skip_serializing_if = "std::option::Option::is_none")]
1284    pub quote_count: Option<i64>,
1285    #[serde(skip_serializing_if = "std::option::Option::is_none")]
1286    pub reply_count: Option<i64>,
1287    #[serde(skip_serializing_if = "std::option::Option::is_none")]
1288    pub repost_count: Option<i64>,
1289    #[serde(borrow)]
1290    pub uri: jacquard_common::types::string::AtUri<'a>,
1291    /// The record data itself.
1292    #[serde(borrow)]
1293    pub value: jacquard_common::types::value::Data<'a>,
1294}
1295
1296pub mod view_record_state {
1297
1298    pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
1299    #[allow(unused)]
1300    use ::core::marker::PhantomData;
1301    mod sealed {
1302        pub trait Sealed {}
1303    }
1304    /// State trait tracking which required fields have been set
1305    pub trait State: sealed::Sealed {
1306        type Uri;
1307        type Cid;
1308        type Author;
1309        type Value;
1310        type IndexedAt;
1311    }
1312    /// Empty state - all required fields are unset
1313    pub struct Empty(());
1314    impl sealed::Sealed for Empty {}
1315    impl State for Empty {
1316        type Uri = Unset;
1317        type Cid = Unset;
1318        type Author = Unset;
1319        type Value = Unset;
1320        type IndexedAt = Unset;
1321    }
1322    ///State transition - sets the `uri` field to Set
1323    pub struct SetUri<S: State = Empty>(PhantomData<fn() -> S>);
1324    impl<S: State> sealed::Sealed for SetUri<S> {}
1325    impl<S: State> State for SetUri<S> {
1326        type Uri = Set<members::uri>;
1327        type Cid = S::Cid;
1328        type Author = S::Author;
1329        type Value = S::Value;
1330        type IndexedAt = S::IndexedAt;
1331    }
1332    ///State transition - sets the `cid` field to Set
1333    pub struct SetCid<S: State = Empty>(PhantomData<fn() -> S>);
1334    impl<S: State> sealed::Sealed for SetCid<S> {}
1335    impl<S: State> State for SetCid<S> {
1336        type Uri = S::Uri;
1337        type Cid = Set<members::cid>;
1338        type Author = S::Author;
1339        type Value = S::Value;
1340        type IndexedAt = S::IndexedAt;
1341    }
1342    ///State transition - sets the `author` field to Set
1343    pub struct SetAuthor<S: State = Empty>(PhantomData<fn() -> S>);
1344    impl<S: State> sealed::Sealed for SetAuthor<S> {}
1345    impl<S: State> State for SetAuthor<S> {
1346        type Uri = S::Uri;
1347        type Cid = S::Cid;
1348        type Author = Set<members::author>;
1349        type Value = S::Value;
1350        type IndexedAt = S::IndexedAt;
1351    }
1352    ///State transition - sets the `value` field to Set
1353    pub struct SetValue<S: State = Empty>(PhantomData<fn() -> S>);
1354    impl<S: State> sealed::Sealed for SetValue<S> {}
1355    impl<S: State> State for SetValue<S> {
1356        type Uri = S::Uri;
1357        type Cid = S::Cid;
1358        type Author = S::Author;
1359        type Value = Set<members::value>;
1360        type IndexedAt = S::IndexedAt;
1361    }
1362    ///State transition - sets the `indexed_at` field to Set
1363    pub struct SetIndexedAt<S: State = Empty>(PhantomData<fn() -> S>);
1364    impl<S: State> sealed::Sealed for SetIndexedAt<S> {}
1365    impl<S: State> State for SetIndexedAt<S> {
1366        type Uri = S::Uri;
1367        type Cid = S::Cid;
1368        type Author = S::Author;
1369        type Value = S::Value;
1370        type IndexedAt = Set<members::indexed_at>;
1371    }
1372    /// Marker types for field names
1373    #[allow(non_camel_case_types)]
1374    pub mod members {
1375        ///Marker type for the `uri` field
1376        pub struct uri(());
1377        ///Marker type for the `cid` field
1378        pub struct cid(());
1379        ///Marker type for the `author` field
1380        pub struct author(());
1381        ///Marker type for the `value` field
1382        pub struct value(());
1383        ///Marker type for the `indexed_at` field
1384        pub struct indexed_at(());
1385    }
1386}
1387
1388/// Builder for constructing an instance of this type
1389pub struct ViewRecordBuilder<'a, S: view_record_state::State> {
1390    _phantom_state: ::core::marker::PhantomData<fn() -> S>,
1391    __unsafe_private_named: (
1392        ::core::option::Option<crate::app_bsky::actor::ProfileViewBasic<'a>>,
1393        ::core::option::Option<jacquard_common::types::string::Cid<'a>>,
1394        ::core::option::Option<Vec<ViewRecordEmbedsItem<'a>>>,
1395        ::core::option::Option<jacquard_common::types::string::Datetime>,
1396        ::core::option::Option<Vec<crate::com_atproto::label::Label<'a>>>,
1397        ::core::option::Option<i64>,
1398        ::core::option::Option<i64>,
1399        ::core::option::Option<i64>,
1400        ::core::option::Option<i64>,
1401        ::core::option::Option<jacquard_common::types::string::AtUri<'a>>,
1402        ::core::option::Option<jacquard_common::types::value::Data<'a>>,
1403    ),
1404    _phantom: ::core::marker::PhantomData<&'a ()>,
1405}
1406
1407impl<'a> ViewRecord<'a> {
1408    /// Create a new builder for this type
1409    pub fn new() -> ViewRecordBuilder<'a, view_record_state::Empty> {
1410        ViewRecordBuilder::new()
1411    }
1412}
1413
1414impl<'a> ViewRecordBuilder<'a, view_record_state::Empty> {
1415    /// Create a new builder with all fields unset
1416    pub fn new() -> Self {
1417        ViewRecordBuilder {
1418            _phantom_state: ::core::marker::PhantomData,
1419            __unsafe_private_named: (
1420                None,
1421                None,
1422                None,
1423                None,
1424                None,
1425                None,
1426                None,
1427                None,
1428                None,
1429                None,
1430                None,
1431            ),
1432            _phantom: ::core::marker::PhantomData,
1433        }
1434    }
1435}
1436
1437impl<'a, S> ViewRecordBuilder<'a, S>
1438where
1439    S: view_record_state::State,
1440    S::Author: view_record_state::IsUnset,
1441{
1442    /// Set the `author` field (required)
1443    pub fn author(
1444        mut self,
1445        value: impl Into<crate::app_bsky::actor::ProfileViewBasic<'a>>,
1446    ) -> ViewRecordBuilder<'a, view_record_state::SetAuthor<S>> {
1447        self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
1448        ViewRecordBuilder {
1449            _phantom_state: ::core::marker::PhantomData,
1450            __unsafe_private_named: self.__unsafe_private_named,
1451            _phantom: ::core::marker::PhantomData,
1452        }
1453    }
1454}
1455
1456impl<'a, S> ViewRecordBuilder<'a, S>
1457where
1458    S: view_record_state::State,
1459    S::Cid: view_record_state::IsUnset,
1460{
1461    /// Set the `cid` field (required)
1462    pub fn cid(
1463        mut self,
1464        value: impl Into<jacquard_common::types::string::Cid<'a>>,
1465    ) -> ViewRecordBuilder<'a, view_record_state::SetCid<S>> {
1466        self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
1467        ViewRecordBuilder {
1468            _phantom_state: ::core::marker::PhantomData,
1469            __unsafe_private_named: self.__unsafe_private_named,
1470            _phantom: ::core::marker::PhantomData,
1471        }
1472    }
1473}
1474
1475impl<'a, S: view_record_state::State> ViewRecordBuilder<'a, S> {
1476    /// Set the `embeds` field (optional)
1477    pub fn embeds(
1478        mut self,
1479        value: impl Into<Option<Vec<ViewRecordEmbedsItem<'a>>>>,
1480    ) -> Self {
1481        self.__unsafe_private_named.2 = value.into();
1482        self
1483    }
1484    /// Set the `embeds` field to an Option value (optional)
1485    pub fn maybe_embeds(mut self, value: Option<Vec<ViewRecordEmbedsItem<'a>>>) -> Self {
1486        self.__unsafe_private_named.2 = value;
1487        self
1488    }
1489}
1490
1491impl<'a, S> ViewRecordBuilder<'a, S>
1492where
1493    S: view_record_state::State,
1494    S::IndexedAt: view_record_state::IsUnset,
1495{
1496    /// Set the `indexedAt` field (required)
1497    pub fn indexed_at(
1498        mut self,
1499        value: impl Into<jacquard_common::types::string::Datetime>,
1500    ) -> ViewRecordBuilder<'a, view_record_state::SetIndexedAt<S>> {
1501        self.__unsafe_private_named.3 = ::core::option::Option::Some(value.into());
1502        ViewRecordBuilder {
1503            _phantom_state: ::core::marker::PhantomData,
1504            __unsafe_private_named: self.__unsafe_private_named,
1505            _phantom: ::core::marker::PhantomData,
1506        }
1507    }
1508}
1509
1510impl<'a, S: view_record_state::State> ViewRecordBuilder<'a, S> {
1511    /// Set the `labels` field (optional)
1512    pub fn labels(
1513        mut self,
1514        value: impl Into<Option<Vec<crate::com_atproto::label::Label<'a>>>>,
1515    ) -> Self {
1516        self.__unsafe_private_named.4 = value.into();
1517        self
1518    }
1519    /// Set the `labels` field to an Option value (optional)
1520    pub fn maybe_labels(
1521        mut self,
1522        value: Option<Vec<crate::com_atproto::label::Label<'a>>>,
1523    ) -> Self {
1524        self.__unsafe_private_named.4 = value;
1525        self
1526    }
1527}
1528
1529impl<'a, S: view_record_state::State> ViewRecordBuilder<'a, S> {
1530    /// Set the `likeCount` field (optional)
1531    pub fn like_count(mut self, value: impl Into<Option<i64>>) -> Self {
1532        self.__unsafe_private_named.5 = value.into();
1533        self
1534    }
1535    /// Set the `likeCount` field to an Option value (optional)
1536    pub fn maybe_like_count(mut self, value: Option<i64>) -> Self {
1537        self.__unsafe_private_named.5 = value;
1538        self
1539    }
1540}
1541
1542impl<'a, S: view_record_state::State> ViewRecordBuilder<'a, S> {
1543    /// Set the `quoteCount` field (optional)
1544    pub fn quote_count(mut self, value: impl Into<Option<i64>>) -> Self {
1545        self.__unsafe_private_named.6 = value.into();
1546        self
1547    }
1548    /// Set the `quoteCount` field to an Option value (optional)
1549    pub fn maybe_quote_count(mut self, value: Option<i64>) -> Self {
1550        self.__unsafe_private_named.6 = value;
1551        self
1552    }
1553}
1554
1555impl<'a, S: view_record_state::State> ViewRecordBuilder<'a, S> {
1556    /// Set the `replyCount` field (optional)
1557    pub fn reply_count(mut self, value: impl Into<Option<i64>>) -> Self {
1558        self.__unsafe_private_named.7 = value.into();
1559        self
1560    }
1561    /// Set the `replyCount` field to an Option value (optional)
1562    pub fn maybe_reply_count(mut self, value: Option<i64>) -> Self {
1563        self.__unsafe_private_named.7 = value;
1564        self
1565    }
1566}
1567
1568impl<'a, S: view_record_state::State> ViewRecordBuilder<'a, S> {
1569    /// Set the `repostCount` field (optional)
1570    pub fn repost_count(mut self, value: impl Into<Option<i64>>) -> Self {
1571        self.__unsafe_private_named.8 = value.into();
1572        self
1573    }
1574    /// Set the `repostCount` field to an Option value (optional)
1575    pub fn maybe_repost_count(mut self, value: Option<i64>) -> Self {
1576        self.__unsafe_private_named.8 = value;
1577        self
1578    }
1579}
1580
1581impl<'a, S> ViewRecordBuilder<'a, S>
1582where
1583    S: view_record_state::State,
1584    S::Uri: view_record_state::IsUnset,
1585{
1586    /// Set the `uri` field (required)
1587    pub fn uri(
1588        mut self,
1589        value: impl Into<jacquard_common::types::string::AtUri<'a>>,
1590    ) -> ViewRecordBuilder<'a, view_record_state::SetUri<S>> {
1591        self.__unsafe_private_named.9 = ::core::option::Option::Some(value.into());
1592        ViewRecordBuilder {
1593            _phantom_state: ::core::marker::PhantomData,
1594            __unsafe_private_named: self.__unsafe_private_named,
1595            _phantom: ::core::marker::PhantomData,
1596        }
1597    }
1598}
1599
1600impl<'a, S> ViewRecordBuilder<'a, S>
1601where
1602    S: view_record_state::State,
1603    S::Value: view_record_state::IsUnset,
1604{
1605    /// Set the `value` field (required)
1606    pub fn value(
1607        mut self,
1608        value: impl Into<jacquard_common::types::value::Data<'a>>,
1609    ) -> ViewRecordBuilder<'a, view_record_state::SetValue<S>> {
1610        self.__unsafe_private_named.10 = ::core::option::Option::Some(value.into());
1611        ViewRecordBuilder {
1612            _phantom_state: ::core::marker::PhantomData,
1613            __unsafe_private_named: self.__unsafe_private_named,
1614            _phantom: ::core::marker::PhantomData,
1615        }
1616    }
1617}
1618
1619impl<'a, S> ViewRecordBuilder<'a, S>
1620where
1621    S: view_record_state::State,
1622    S::Uri: view_record_state::IsSet,
1623    S::Cid: view_record_state::IsSet,
1624    S::Author: view_record_state::IsSet,
1625    S::Value: view_record_state::IsSet,
1626    S::IndexedAt: view_record_state::IsSet,
1627{
1628    /// Build the final struct
1629    pub fn build(self) -> ViewRecord<'a> {
1630        ViewRecord {
1631            author: self.__unsafe_private_named.0.unwrap(),
1632            cid: self.__unsafe_private_named.1.unwrap(),
1633            embeds: self.__unsafe_private_named.2,
1634            indexed_at: self.__unsafe_private_named.3.unwrap(),
1635            labels: self.__unsafe_private_named.4,
1636            like_count: self.__unsafe_private_named.5,
1637            quote_count: self.__unsafe_private_named.6,
1638            reply_count: self.__unsafe_private_named.7,
1639            repost_count: self.__unsafe_private_named.8,
1640            uri: self.__unsafe_private_named.9.unwrap(),
1641            value: self.__unsafe_private_named.10.unwrap(),
1642            extra_data: Default::default(),
1643        }
1644    }
1645    /// Build the final struct with custom extra_data
1646    pub fn build_with_data(
1647        self,
1648        extra_data: std::collections::BTreeMap<
1649            jacquard_common::smol_str::SmolStr,
1650            jacquard_common::types::value::Data<'a>,
1651        >,
1652    ) -> ViewRecord<'a> {
1653        ViewRecord {
1654            author: self.__unsafe_private_named.0.unwrap(),
1655            cid: self.__unsafe_private_named.1.unwrap(),
1656            embeds: self.__unsafe_private_named.2,
1657            indexed_at: self.__unsafe_private_named.3.unwrap(),
1658            labels: self.__unsafe_private_named.4,
1659            like_count: self.__unsafe_private_named.5,
1660            quote_count: self.__unsafe_private_named.6,
1661            reply_count: self.__unsafe_private_named.7,
1662            repost_count: self.__unsafe_private_named.8,
1663            uri: self.__unsafe_private_named.9.unwrap(),
1664            value: self.__unsafe_private_named.10.unwrap(),
1665            extra_data: Some(extra_data),
1666        }
1667    }
1668}
1669
1670#[jacquard_derive::open_union]
1671#[derive(
1672    serde::Serialize,
1673    serde::Deserialize,
1674    Debug,
1675    Clone,
1676    PartialEq,
1677    Eq,
1678    jacquard_derive::IntoStatic
1679)]
1680#[serde(tag = "$type")]
1681#[serde(bound(deserialize = "'de: 'a"))]
1682pub enum ViewRecordEmbedsItem<'a> {
1683    #[serde(rename = "app.bsky.embed.images#view")]
1684    ImagesView(Box<crate::app_bsky::embed::images::View<'a>>),
1685    #[serde(rename = "app.bsky.embed.video#view")]
1686    VideoView(Box<crate::app_bsky::embed::video::View<'a>>),
1687    #[serde(rename = "app.bsky.embed.external#view")]
1688    ExternalView(Box<crate::app_bsky::embed::external::View<'a>>),
1689    #[serde(rename = "app.bsky.embed.record#view")]
1690    View(Box<crate::app_bsky::embed::record::View<'a>>),
1691    #[serde(rename = "app.bsky.embed.recordWithMedia#view")]
1692    RecordWithMediaView(Box<crate::app_bsky::embed::record_with_media::View<'a>>),
1693}
1694
1695impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ViewRecord<'a> {
1696    fn nsid() -> &'static str {
1697        "app.bsky.embed.record"
1698    }
1699    fn def_name() -> &'static str {
1700        "viewRecord"
1701    }
1702    fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
1703        lexicon_doc_app_bsky_embed_record()
1704    }
1705    fn validate(
1706        &self,
1707    ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
1708        Ok(())
1709    }
1710}
jacquard_api/app_bsky/embed/record.rs

jacquard_api/app_bsky/embed/
record.rs
