jacquard_api/app_bsky/actor/
status.rs

1// @generated by jacquard-lexicon. DO NOT EDIT.
2//
3// Lexicon: app.bsky.actor.status
4//
5// This file was automatically generated from Lexicon schemas.
6// Any manual changes will be overwritten on the next regeneration.
7
8#[allow(unused_imports)]
9use alloc::collections::BTreeMap;
10
11#[allow(unused_imports)]
12use core::marker::PhantomData;
13use jacquard_common::CowStr;
14
15#[allow(unused_imports)]
16use jacquard_common::deps::codegen::unicode_segmentation::UnicodeSegmentation;
17use jacquard_common::types::collection::{Collection, RecordError};
18use jacquard_common::types::string::{AtUri, Cid, Datetime};
19use jacquard_common::types::uri::{RecordUri, UriError};
20use jacquard_common::xrpc::XrpcResp;
21use jacquard_derive::{IntoStatic, lexicon};
22use jacquard_lexicon::lexicon::LexiconDoc;
23use jacquard_lexicon::schema::LexiconSchema;
24
25#[allow(unused_imports)]
26use jacquard_lexicon::validation::{ConstraintError, ValidationPath};
27use serde::{Serialize, Deserialize};
28use crate::app_bsky::embed::external::ExternalRecord;
29/// Advertises an account as currently offering live content.
30
31#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
32pub struct Live;
33impl core::fmt::Display for Live {
34    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
35        write!(f, "live")
36    }
37}
38
39/// A declaration of a Bluesky account status.
40
41#[lexicon]
42#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
43#[serde(rename_all = "camelCase", rename = "app.bsky.actor.status", tag = "$type")]
44pub struct Status<'a> {
45    pub created_at: Datetime,
46    ///The duration of the status in minutes. Applications can choose to impose minimum and maximum limits.
47    #[serde(skip_serializing_if = "Option::is_none")]
48    pub duration_minutes: Option<i64>,
49    ///An optional embed associated with the status.
50    #[serde(skip_serializing_if = "Option::is_none")]
51    #[serde(borrow)]
52    pub embed: Option<ExternalRecord<'a>>,
53    ///The status for the account.
54    #[serde(borrow)]
55    pub status: StatusStatus<'a>,
56}
57
58/// The status for the account.
59
60#[derive(Debug, Clone, PartialEq, Eq, Hash)]
61pub enum StatusStatus<'a> {
62    Live,
63    Other(CowStr<'a>),
64}
65
66impl<'a> StatusStatus<'a> {
67    pub fn as_str(&self) -> &str {
68        match self {
69            Self::Live => "app.bsky.actor.status#live",
70            Self::Other(s) => s.as_ref(),
71        }
72    }
73}
74
75impl<'a> From<&'a str> for StatusStatus<'a> {
76    fn from(s: &'a str) -> Self {
77        match s {
78            "app.bsky.actor.status#live" => Self::Live,
79            _ => Self::Other(CowStr::from(s)),
80        }
81    }
82}
83
84impl<'a> From<String> for StatusStatus<'a> {
85    fn from(s: String) -> Self {
86        match s.as_str() {
87            "app.bsky.actor.status#live" => Self::Live,
88            _ => Self::Other(CowStr::from(s)),
89        }
90    }
91}
92
93impl<'a> core::fmt::Display for StatusStatus<'a> {
94    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
95        write!(f, "{}", self.as_str())
96    }
97}
98
99impl<'a> AsRef<str> for StatusStatus<'a> {
100    fn as_ref(&self) -> &str {
101        self.as_str()
102    }
103}
104
105impl<'a> serde::Serialize for StatusStatus<'a> {
106    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
107    where
108        S: serde::Serializer,
109    {
110        serializer.serialize_str(self.as_str())
111    }
112}
113
114impl<'de, 'a> serde::Deserialize<'de> for StatusStatus<'a>
115where
116    'de: 'a,
117{
118    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
119    where
120        D: serde::Deserializer<'de>,
121    {
122        let s = <&'de str>::deserialize(deserializer)?;
123        Ok(Self::from(s))
124    }
125}
126
127impl<'a> Default for StatusStatus<'a> {
128    fn default() -> Self {
129        Self::Other(Default::default())
130    }
131}
132
133impl jacquard_common::IntoStatic for StatusStatus<'_> {
134    type Output = StatusStatus<'static>;
135    fn into_static(self) -> Self::Output {
136        match self {
137            StatusStatus::Live => StatusStatus::Live,
138            StatusStatus::Other(v) => StatusStatus::Other(v.into_static()),
139        }
140    }
141}
142
143/// Typed wrapper for GetRecord response with this collection's record type.
144
145#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
146#[serde(rename_all = "camelCase")]
147pub struct StatusGetRecordOutput<'a> {
148    #[serde(skip_serializing_if = "Option::is_none")]
149    #[serde(borrow)]
150    pub cid: Option<Cid<'a>>,
151    #[serde(borrow)]
152    pub uri: AtUri<'a>,
153    #[serde(borrow)]
154    pub value: Status<'a>,
155}
156
157impl<'a> Status<'a> {
158    pub fn uri(
159        uri: impl Into<CowStr<'a>>,
160    ) -> Result<RecordUri<'a, StatusRecord>, UriError> {
161        RecordUri::try_from_uri(AtUri::new_cow(uri.into())?)
162    }
163}
164
165/// Marker type for deserializing records from this collection.
166
167#[derive(Debug, Serialize, Deserialize)]
168pub struct StatusRecord;
169impl XrpcResp for StatusRecord {
170    const NSID: &'static str = "app.bsky.actor.status";
171    const ENCODING: &'static str = "application/json";
172    type Output<'de> = StatusGetRecordOutput<'de>;
173    type Err<'de> = RecordError<'de>;
174}
175
176impl From<StatusGetRecordOutput<'_>> for Status<'_> {
177    fn from(output: StatusGetRecordOutput<'_>) -> Self {
178        use jacquard_common::IntoStatic;
179        output.value.into_static()
180    }
181}
182
183impl Collection for Status<'_> {
184    const NSID: &'static str = "app.bsky.actor.status";
185    type Record = StatusRecord;
186}
187
188impl Collection for StatusRecord {
189    const NSID: &'static str = "app.bsky.actor.status";
190    type Record = StatusRecord;
191}
192
193impl<'a> LexiconSchema for Status<'a> {
194    fn nsid() -> &'static str {
195        "app.bsky.actor.status"
196    }
197    fn def_name() -> &'static str {
198        "main"
199    }
200    fn lexicon_doc() -> LexiconDoc<'static> {
201        lexicon_doc_app_bsky_actor_status()
202    }
203    fn validate(&self) -> Result<(), ConstraintError> {
204        if let Some(ref value) = self.duration_minutes {
205            if *value < 1i64 {
206                return Err(ConstraintError::Minimum {
207                    path: ValidationPath::from_field("duration_minutes"),
208                    min: 1i64,
209                    actual: *value,
210                });
211            }
212        }
213        Ok(())
214    }
215}
216
217pub mod status_state {
218
219    pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
220    #[allow(unused)]
221    use ::core::marker::PhantomData;
222    mod sealed {
223        pub trait Sealed {}
224    }
225    /// State trait tracking which required fields have been set
226    pub trait State: sealed::Sealed {
227        type CreatedAt;
228        type Status;
229    }
230    /// Empty state - all required fields are unset
231    pub struct Empty(());
232    impl sealed::Sealed for Empty {}
233    impl State for Empty {
234        type CreatedAt = Unset;
235        type Status = Unset;
236    }
237    ///State transition - sets the `created_at` field to Set
238    pub struct SetCreatedAt<S: State = Empty>(PhantomData<fn() -> S>);
239    impl<S: State> sealed::Sealed for SetCreatedAt<S> {}
240    impl<S: State> State for SetCreatedAt<S> {
241        type CreatedAt = Set<members::created_at>;
242        type Status = S::Status;
243    }
244    ///State transition - sets the `status` field to Set
245    pub struct SetStatus<S: State = Empty>(PhantomData<fn() -> S>);
246    impl<S: State> sealed::Sealed for SetStatus<S> {}
247    impl<S: State> State for SetStatus<S> {
248        type CreatedAt = S::CreatedAt;
249        type Status = Set<members::status>;
250    }
251    /// Marker types for field names
252    #[allow(non_camel_case_types)]
253    pub mod members {
254        ///Marker type for the `created_at` field
255        pub struct created_at(());
256        ///Marker type for the `status` field
257        pub struct status(());
258    }
259}
260
261/// Builder for constructing an instance of this type
262pub struct StatusBuilder<'a, S: status_state::State> {
263    _state: PhantomData<fn() -> S>,
264    _fields: (
265        Option<Datetime>,
266        Option<i64>,
267        Option<ExternalRecord<'a>>,
268        Option<StatusStatus<'a>>,
269    ),
270    _lifetime: PhantomData<&'a ()>,
271}
272
273impl<'a> Status<'a> {
274    /// Create a new builder for this type
275    pub fn new() -> StatusBuilder<'a, status_state::Empty> {
276        StatusBuilder::new()
277    }
278}
279
280impl<'a> StatusBuilder<'a, status_state::Empty> {
281    /// Create a new builder with all fields unset
282    pub fn new() -> Self {
283        StatusBuilder {
284            _state: PhantomData,
285            _fields: (None, None, None, None),
286            _lifetime: PhantomData,
287        }
288    }
289}
290
291impl<'a, S> StatusBuilder<'a, S>
292where
293    S: status_state::State,
294    S::CreatedAt: status_state::IsUnset,
295{
296    /// Set the `createdAt` field (required)
297    pub fn created_at(
298        mut self,
299        value: impl Into<Datetime>,
300    ) -> StatusBuilder<'a, status_state::SetCreatedAt<S>> {
301        self._fields.0 = Option::Some(value.into());
302        StatusBuilder {
303            _state: PhantomData,
304            _fields: self._fields,
305            _lifetime: PhantomData,
306        }
307    }
308}
309
310impl<'a, S: status_state::State> StatusBuilder<'a, S> {
311    /// Set the `durationMinutes` field (optional)
312    pub fn duration_minutes(mut self, value: impl Into<Option<i64>>) -> Self {
313        self._fields.1 = value.into();
314        self
315    }
316    /// Set the `durationMinutes` field to an Option value (optional)
317    pub fn maybe_duration_minutes(mut self, value: Option<i64>) -> Self {
318        self._fields.1 = value;
319        self
320    }
321}
322
323impl<'a, S: status_state::State> StatusBuilder<'a, S> {
324    /// Set the `embed` field (optional)
325    pub fn embed(mut self, value: impl Into<Option<ExternalRecord<'a>>>) -> Self {
326        self._fields.2 = value.into();
327        self
328    }
329    /// Set the `embed` field to an Option value (optional)
330    pub fn maybe_embed(mut self, value: Option<ExternalRecord<'a>>) -> Self {
331        self._fields.2 = value;
332        self
333    }
334}
335
336impl<'a, S> StatusBuilder<'a, S>
337where
338    S: status_state::State,
339    S::Status: status_state::IsUnset,
340{
341    /// Set the `status` field (required)
342    pub fn status(
343        mut self,
344        value: impl Into<StatusStatus<'a>>,
345    ) -> StatusBuilder<'a, status_state::SetStatus<S>> {
346        self._fields.3 = Option::Some(value.into());
347        StatusBuilder {
348            _state: PhantomData,
349            _fields: self._fields,
350            _lifetime: PhantomData,
351        }
352    }
353}
354
355impl<'a, S> StatusBuilder<'a, S>
356where
357    S: status_state::State,
358    S::CreatedAt: status_state::IsSet,
359    S::Status: status_state::IsSet,
360{
361    /// Build the final struct
362    pub fn build(self) -> Status<'a> {
363        Status {
364            created_at: self._fields.0.unwrap(),
365            duration_minutes: self._fields.1,
366            embed: self._fields.2,
367            status: self._fields.3.unwrap(),
368            extra_data: Default::default(),
369        }
370    }
371    /// Build the final struct with custom extra_data
372    pub fn build_with_data(
373        self,
374        extra_data: BTreeMap<
375            jacquard_common::deps::smol_str::SmolStr,
376            jacquard_common::types::value::Data<'a>,
377        >,
378    ) -> Status<'a> {
379        Status {
380            created_at: self._fields.0.unwrap(),
381            duration_minutes: self._fields.1,
382            embed: self._fields.2,
383            status: self._fields.3.unwrap(),
384            extra_data: Some(extra_data),
385        }
386    }
387}
388
389fn lexicon_doc_app_bsky_actor_status() -> LexiconDoc<'static> {
390    #[allow(unused_imports)]
391    use jacquard_common::{CowStr, deps::smol_str::SmolStr, types::blob::MimeType};
392    use jacquard_lexicon::lexicon::*;
393    use alloc::collections::BTreeMap;
394    LexiconDoc {
395        lexicon: Lexicon::Lexicon1,
396        id: CowStr::new_static("app.bsky.actor.status"),
397        defs: {
398            let mut map = BTreeMap::new();
399            map.insert(
400                SmolStr::new_static("live"),
401                LexUserType::Token(LexToken { ..Default::default() }),
402            );
403            map.insert(
404                SmolStr::new_static("main"),
405                LexUserType::Record(LexRecord {
406                    description: Some(
407                        CowStr::new_static("A declaration of a Bluesky account status."),
408                    ),
409                    key: Some(CowStr::new_static("literal:self")),
410                    record: LexRecordRecord::Object(LexObject {
411                        required: Some(
412                            vec![
413                                SmolStr::new_static("status"),
414                                SmolStr::new_static("createdAt")
415                            ],
416                        ),
417                        properties: {
418                            #[allow(unused_mut)]
419                            let mut map = BTreeMap::new();
420                            map.insert(
421                                SmolStr::new_static("createdAt"),
422                                LexObjectProperty::String(LexString {
423                                    format: Some(LexStringFormat::Datetime),
424                                    ..Default::default()
425                                }),
426                            );
427                            map.insert(
428                                SmolStr::new_static("durationMinutes"),
429                                LexObjectProperty::Integer(LexInteger {
430                                    minimum: Some(1i64),
431                                    ..Default::default()
432                                }),
433                            );
434                            map.insert(
435                                SmolStr::new_static("embed"),
436                                LexObjectProperty::Union(LexRefUnion {
437                                    description: Some(
438                                        CowStr::new_static(
439                                            "An optional embed associated with the status.",
440                                        ),
441                                    ),
442                                    refs: vec![CowStr::new_static("app.bsky.embed.external")],
443                                    ..Default::default()
444                                }),
445                            );
446                            map.insert(
447                                SmolStr::new_static("status"),
448                                LexObjectProperty::String(LexString {
449                                    description: Some(
450                                        CowStr::new_static("The status for the account."),
451                                    ),
452                                    ..Default::default()
453                                }),
454                            );
455                            map
456                        },
457                        ..Default::default()
458                    }),
459                    ..Default::default()
460                }),
461            );
462            map
463        },
464        ..Default::default()
465    }
466}
jacquard_api/app_bsky/actor/status.rs

jacquard_api/app_bsky/actor/
status.rs
