jacquard_api/com_atproto/
server.rs

1// @generated by jacquard-lexicon. DO NOT EDIT.
2//
3// Lexicon: com.atproto.server.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 activate_account;
9pub mod check_account_status;
10pub mod confirm_email;
11pub mod create_account;
12pub mod create_app_password;
13pub mod create_invite_code;
14pub mod create_invite_codes;
15pub mod create_session;
16pub mod deactivate_account;
17pub mod delete_account;
18pub mod delete_session;
19pub mod describe_server;
20pub mod get_account_invite_codes;
21pub mod get_service_auth;
22pub mod get_session;
23pub mod list_app_passwords;
24pub mod refresh_session;
25pub mod request_account_delete;
26pub mod request_email_confirmation;
27pub mod request_email_update;
28pub mod request_password_reset;
29pub mod reserve_signing_key;
30pub mod reset_password;
31pub mod revoke_app_password;
32pub mod update_email;
33
34
35#[allow(unused_imports)]
36use alloc::collections::BTreeMap;
37
38#[allow(unused_imports)]
39use core::marker::PhantomData;
40use jacquard_common::CowStr;
41
42#[allow(unused_imports)]
43use jacquard_common::deps::codegen::unicode_segmentation::UnicodeSegmentation;
44use jacquard_common::types::string::{Did, Datetime};
45use jacquard_derive::{IntoStatic, lexicon};
46use jacquard_lexicon::lexicon::LexiconDoc;
47use jacquard_lexicon::schema::LexiconSchema;
48
49#[allow(unused_imports)]
50use jacquard_lexicon::validation::{ConstraintError, ValidationPath};
51use serde::{Serialize, Deserialize};
52use crate::com_atproto::server;
53
54#[lexicon]
55#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
56#[serde(rename_all = "camelCase")]
57pub struct InviteCode<'a> {
58    pub available: i64,
59    #[serde(borrow)]
60    pub code: CowStr<'a>,
61    pub created_at: Datetime,
62    #[serde(borrow)]
63    pub created_by: CowStr<'a>,
64    pub disabled: bool,
65    #[serde(borrow)]
66    pub for_account: CowStr<'a>,
67    #[serde(borrow)]
68    pub uses: Vec<server::InviteCodeUse<'a>>,
69}
70
71
72#[lexicon]
73#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
74#[serde(rename_all = "camelCase")]
75pub struct InviteCodeUse<'a> {
76    pub used_at: Datetime,
77    #[serde(borrow)]
78    pub used_by: Did<'a>,
79}
80
81impl<'a> LexiconSchema for InviteCode<'a> {
82    fn nsid() -> &'static str {
83        "com.atproto.server.defs"
84    }
85    fn def_name() -> &'static str {
86        "inviteCode"
87    }
88    fn lexicon_doc() -> LexiconDoc<'static> {
89        lexicon_doc_com_atproto_server_defs()
90    }
91    fn validate(&self) -> Result<(), ConstraintError> {
92        Ok(())
93    }
94}
95
96impl<'a> LexiconSchema for InviteCodeUse<'a> {
97    fn nsid() -> &'static str {
98        "com.atproto.server.defs"
99    }
100    fn def_name() -> &'static str {
101        "inviteCodeUse"
102    }
103    fn lexicon_doc() -> LexiconDoc<'static> {
104        lexicon_doc_com_atproto_server_defs()
105    }
106    fn validate(&self) -> Result<(), ConstraintError> {
107        Ok(())
108    }
109}
110
111pub mod invite_code_state {
112
113    pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
114    #[allow(unused)]
115    use ::core::marker::PhantomData;
116    mod sealed {
117        pub trait Sealed {}
118    }
119    /// State trait tracking which required fields have been set
120    pub trait State: sealed::Sealed {
121        type CreatedAt;
122        type Disabled;
123        type Available;
124        type Code;
125        type ForAccount;
126        type Uses;
127        type CreatedBy;
128    }
129    /// Empty state - all required fields are unset
130    pub struct Empty(());
131    impl sealed::Sealed for Empty {}
132    impl State for Empty {
133        type CreatedAt = Unset;
134        type Disabled = Unset;
135        type Available = Unset;
136        type Code = Unset;
137        type ForAccount = Unset;
138        type Uses = Unset;
139        type CreatedBy = Unset;
140    }
141    ///State transition - sets the `created_at` field to Set
142    pub struct SetCreatedAt<S: State = Empty>(PhantomData<fn() -> S>);
143    impl<S: State> sealed::Sealed for SetCreatedAt<S> {}
144    impl<S: State> State for SetCreatedAt<S> {
145        type CreatedAt = Set<members::created_at>;
146        type Disabled = S::Disabled;
147        type Available = S::Available;
148        type Code = S::Code;
149        type ForAccount = S::ForAccount;
150        type Uses = S::Uses;
151        type CreatedBy = S::CreatedBy;
152    }
153    ///State transition - sets the `disabled` field to Set
154    pub struct SetDisabled<S: State = Empty>(PhantomData<fn() -> S>);
155    impl<S: State> sealed::Sealed for SetDisabled<S> {}
156    impl<S: State> State for SetDisabled<S> {
157        type CreatedAt = S::CreatedAt;
158        type Disabled = Set<members::disabled>;
159        type Available = S::Available;
160        type Code = S::Code;
161        type ForAccount = S::ForAccount;
162        type Uses = S::Uses;
163        type CreatedBy = S::CreatedBy;
164    }
165    ///State transition - sets the `available` field to Set
166    pub struct SetAvailable<S: State = Empty>(PhantomData<fn() -> S>);
167    impl<S: State> sealed::Sealed for SetAvailable<S> {}
168    impl<S: State> State for SetAvailable<S> {
169        type CreatedAt = S::CreatedAt;
170        type Disabled = S::Disabled;
171        type Available = Set<members::available>;
172        type Code = S::Code;
173        type ForAccount = S::ForAccount;
174        type Uses = S::Uses;
175        type CreatedBy = S::CreatedBy;
176    }
177    ///State transition - sets the `code` field to Set
178    pub struct SetCode<S: State = Empty>(PhantomData<fn() -> S>);
179    impl<S: State> sealed::Sealed for SetCode<S> {}
180    impl<S: State> State for SetCode<S> {
181        type CreatedAt = S::CreatedAt;
182        type Disabled = S::Disabled;
183        type Available = S::Available;
184        type Code = Set<members::code>;
185        type ForAccount = S::ForAccount;
186        type Uses = S::Uses;
187        type CreatedBy = S::CreatedBy;
188    }
189    ///State transition - sets the `for_account` field to Set
190    pub struct SetForAccount<S: State = Empty>(PhantomData<fn() -> S>);
191    impl<S: State> sealed::Sealed for SetForAccount<S> {}
192    impl<S: State> State for SetForAccount<S> {
193        type CreatedAt = S::CreatedAt;
194        type Disabled = S::Disabled;
195        type Available = S::Available;
196        type Code = S::Code;
197        type ForAccount = Set<members::for_account>;
198        type Uses = S::Uses;
199        type CreatedBy = S::CreatedBy;
200    }
201    ///State transition - sets the `uses` field to Set
202    pub struct SetUses<S: State = Empty>(PhantomData<fn() -> S>);
203    impl<S: State> sealed::Sealed for SetUses<S> {}
204    impl<S: State> State for SetUses<S> {
205        type CreatedAt = S::CreatedAt;
206        type Disabled = S::Disabled;
207        type Available = S::Available;
208        type Code = S::Code;
209        type ForAccount = S::ForAccount;
210        type Uses = Set<members::uses>;
211        type CreatedBy = S::CreatedBy;
212    }
213    ///State transition - sets the `created_by` field to Set
214    pub struct SetCreatedBy<S: State = Empty>(PhantomData<fn() -> S>);
215    impl<S: State> sealed::Sealed for SetCreatedBy<S> {}
216    impl<S: State> State for SetCreatedBy<S> {
217        type CreatedAt = S::CreatedAt;
218        type Disabled = S::Disabled;
219        type Available = S::Available;
220        type Code = S::Code;
221        type ForAccount = S::ForAccount;
222        type Uses = S::Uses;
223        type CreatedBy = Set<members::created_by>;
224    }
225    /// Marker types for field names
226    #[allow(non_camel_case_types)]
227    pub mod members {
228        ///Marker type for the `created_at` field
229        pub struct created_at(());
230        ///Marker type for the `disabled` field
231        pub struct disabled(());
232        ///Marker type for the `available` field
233        pub struct available(());
234        ///Marker type for the `code` field
235        pub struct code(());
236        ///Marker type for the `for_account` field
237        pub struct for_account(());
238        ///Marker type for the `uses` field
239        pub struct uses(());
240        ///Marker type for the `created_by` field
241        pub struct created_by(());
242    }
243}
244
245/// Builder for constructing an instance of this type
246pub struct InviteCodeBuilder<'a, S: invite_code_state::State> {
247    _state: PhantomData<fn() -> S>,
248    _fields: (
249        Option<i64>,
250        Option<CowStr<'a>>,
251        Option<Datetime>,
252        Option<CowStr<'a>>,
253        Option<bool>,
254        Option<CowStr<'a>>,
255        Option<Vec<server::InviteCodeUse<'a>>>,
256    ),
257    _lifetime: PhantomData<&'a ()>,
258}
259
260impl<'a> InviteCode<'a> {
261    /// Create a new builder for this type
262    pub fn new() -> InviteCodeBuilder<'a, invite_code_state::Empty> {
263        InviteCodeBuilder::new()
264    }
265}
266
267impl<'a> InviteCodeBuilder<'a, invite_code_state::Empty> {
268    /// Create a new builder with all fields unset
269    pub fn new() -> Self {
270        InviteCodeBuilder {
271            _state: PhantomData,
272            _fields: (None, None, None, None, None, None, None),
273            _lifetime: PhantomData,
274        }
275    }
276}
277
278impl<'a, S> InviteCodeBuilder<'a, S>
279where
280    S: invite_code_state::State,
281    S::Available: invite_code_state::IsUnset,
282{
283    /// Set the `available` field (required)
284    pub fn available(
285        mut self,
286        value: impl Into<i64>,
287    ) -> InviteCodeBuilder<'a, invite_code_state::SetAvailable<S>> {
288        self._fields.0 = Option::Some(value.into());
289        InviteCodeBuilder {
290            _state: PhantomData,
291            _fields: self._fields,
292            _lifetime: PhantomData,
293        }
294    }
295}
296
297impl<'a, S> InviteCodeBuilder<'a, S>
298where
299    S: invite_code_state::State,
300    S::Code: invite_code_state::IsUnset,
301{
302    /// Set the `code` field (required)
303    pub fn code(
304        mut self,
305        value: impl Into<CowStr<'a>>,
306    ) -> InviteCodeBuilder<'a, invite_code_state::SetCode<S>> {
307        self._fields.1 = Option::Some(value.into());
308        InviteCodeBuilder {
309            _state: PhantomData,
310            _fields: self._fields,
311            _lifetime: PhantomData,
312        }
313    }
314}
315
316impl<'a, S> InviteCodeBuilder<'a, S>
317where
318    S: invite_code_state::State,
319    S::CreatedAt: invite_code_state::IsUnset,
320{
321    /// Set the `createdAt` field (required)
322    pub fn created_at(
323        mut self,
324        value: impl Into<Datetime>,
325    ) -> InviteCodeBuilder<'a, invite_code_state::SetCreatedAt<S>> {
326        self._fields.2 = Option::Some(value.into());
327        InviteCodeBuilder {
328            _state: PhantomData,
329            _fields: self._fields,
330            _lifetime: PhantomData,
331        }
332    }
333}
334
335impl<'a, S> InviteCodeBuilder<'a, S>
336where
337    S: invite_code_state::State,
338    S::CreatedBy: invite_code_state::IsUnset,
339{
340    /// Set the `createdBy` field (required)
341    pub fn created_by(
342        mut self,
343        value: impl Into<CowStr<'a>>,
344    ) -> InviteCodeBuilder<'a, invite_code_state::SetCreatedBy<S>> {
345        self._fields.3 = Option::Some(value.into());
346        InviteCodeBuilder {
347            _state: PhantomData,
348            _fields: self._fields,
349            _lifetime: PhantomData,
350        }
351    }
352}
353
354impl<'a, S> InviteCodeBuilder<'a, S>
355where
356    S: invite_code_state::State,
357    S::Disabled: invite_code_state::IsUnset,
358{
359    /// Set the `disabled` field (required)
360    pub fn disabled(
361        mut self,
362        value: impl Into<bool>,
363    ) -> InviteCodeBuilder<'a, invite_code_state::SetDisabled<S>> {
364        self._fields.4 = Option::Some(value.into());
365        InviteCodeBuilder {
366            _state: PhantomData,
367            _fields: self._fields,
368            _lifetime: PhantomData,
369        }
370    }
371}
372
373impl<'a, S> InviteCodeBuilder<'a, S>
374where
375    S: invite_code_state::State,
376    S::ForAccount: invite_code_state::IsUnset,
377{
378    /// Set the `forAccount` field (required)
379    pub fn for_account(
380        mut self,
381        value: impl Into<CowStr<'a>>,
382    ) -> InviteCodeBuilder<'a, invite_code_state::SetForAccount<S>> {
383        self._fields.5 = Option::Some(value.into());
384        InviteCodeBuilder {
385            _state: PhantomData,
386            _fields: self._fields,
387            _lifetime: PhantomData,
388        }
389    }
390}
391
392impl<'a, S> InviteCodeBuilder<'a, S>
393where
394    S: invite_code_state::State,
395    S::Uses: invite_code_state::IsUnset,
396{
397    /// Set the `uses` field (required)
398    pub fn uses(
399        mut self,
400        value: impl Into<Vec<server::InviteCodeUse<'a>>>,
401    ) -> InviteCodeBuilder<'a, invite_code_state::SetUses<S>> {
402        self._fields.6 = Option::Some(value.into());
403        InviteCodeBuilder {
404            _state: PhantomData,
405            _fields: self._fields,
406            _lifetime: PhantomData,
407        }
408    }
409}
410
411impl<'a, S> InviteCodeBuilder<'a, S>
412where
413    S: invite_code_state::State,
414    S::CreatedAt: invite_code_state::IsSet,
415    S::Disabled: invite_code_state::IsSet,
416    S::Available: invite_code_state::IsSet,
417    S::Code: invite_code_state::IsSet,
418    S::ForAccount: invite_code_state::IsSet,
419    S::Uses: invite_code_state::IsSet,
420    S::CreatedBy: invite_code_state::IsSet,
421{
422    /// Build the final struct
423    pub fn build(self) -> InviteCode<'a> {
424        InviteCode {
425            available: self._fields.0.unwrap(),
426            code: self._fields.1.unwrap(),
427            created_at: self._fields.2.unwrap(),
428            created_by: self._fields.3.unwrap(),
429            disabled: self._fields.4.unwrap(),
430            for_account: self._fields.5.unwrap(),
431            uses: self._fields.6.unwrap(),
432            extra_data: Default::default(),
433        }
434    }
435    /// Build the final struct with custom extra_data
436    pub fn build_with_data(
437        self,
438        extra_data: BTreeMap<
439            jacquard_common::deps::smol_str::SmolStr,
440            jacquard_common::types::value::Data<'a>,
441        >,
442    ) -> InviteCode<'a> {
443        InviteCode {
444            available: self._fields.0.unwrap(),
445            code: self._fields.1.unwrap(),
446            created_at: self._fields.2.unwrap(),
447            created_by: self._fields.3.unwrap(),
448            disabled: self._fields.4.unwrap(),
449            for_account: self._fields.5.unwrap(),
450            uses: self._fields.6.unwrap(),
451            extra_data: Some(extra_data),
452        }
453    }
454}
455
456fn lexicon_doc_com_atproto_server_defs() -> LexiconDoc<'static> {
457    #[allow(unused_imports)]
458    use jacquard_common::{CowStr, deps::smol_str::SmolStr, types::blob::MimeType};
459    use jacquard_lexicon::lexicon::*;
460    use alloc::collections::BTreeMap;
461    LexiconDoc {
462        lexicon: Lexicon::Lexicon1,
463        id: CowStr::new_static("com.atproto.server.defs"),
464        defs: {
465            let mut map = BTreeMap::new();
466            map.insert(
467                SmolStr::new_static("inviteCode"),
468                LexUserType::Object(LexObject {
469                    required: Some(
470                        vec![
471                            SmolStr::new_static("code"),
472                            SmolStr::new_static("available"),
473                            SmolStr::new_static("disabled"),
474                            SmolStr::new_static("forAccount"),
475                            SmolStr::new_static("createdBy"),
476                            SmolStr::new_static("createdAt"), SmolStr::new_static("uses")
477                        ],
478                    ),
479                    properties: {
480                        #[allow(unused_mut)]
481                        let mut map = BTreeMap::new();
482                        map.insert(
483                            SmolStr::new_static("available"),
484                            LexObjectProperty::Integer(LexInteger {
485                                ..Default::default()
486                            }),
487                        );
488                        map.insert(
489                            SmolStr::new_static("code"),
490                            LexObjectProperty::String(LexString { ..Default::default() }),
491                        );
492                        map.insert(
493                            SmolStr::new_static("createdAt"),
494                            LexObjectProperty::String(LexString {
495                                format: Some(LexStringFormat::Datetime),
496                                ..Default::default()
497                            }),
498                        );
499                        map.insert(
500                            SmolStr::new_static("createdBy"),
501                            LexObjectProperty::String(LexString { ..Default::default() }),
502                        );
503                        map.insert(
504                            SmolStr::new_static("disabled"),
505                            LexObjectProperty::Boolean(LexBoolean {
506                                ..Default::default()
507                            }),
508                        );
509                        map.insert(
510                            SmolStr::new_static("forAccount"),
511                            LexObjectProperty::String(LexString { ..Default::default() }),
512                        );
513                        map.insert(
514                            SmolStr::new_static("uses"),
515                            LexObjectProperty::Array(LexArray {
516                                items: LexArrayItem::Ref(LexRef {
517                                    r#ref: CowStr::new_static("#inviteCodeUse"),
518                                    ..Default::default()
519                                }),
520                                ..Default::default()
521                            }),
522                        );
523                        map
524                    },
525                    ..Default::default()
526                }),
527            );
528            map.insert(
529                SmolStr::new_static("inviteCodeUse"),
530                LexUserType::Object(LexObject {
531                    required: Some(
532                        vec![
533                            SmolStr::new_static("usedBy"), SmolStr::new_static("usedAt")
534                        ],
535                    ),
536                    properties: {
537                        #[allow(unused_mut)]
538                        let mut map = BTreeMap::new();
539                        map.insert(
540                            SmolStr::new_static("usedAt"),
541                            LexObjectProperty::String(LexString {
542                                format: Some(LexStringFormat::Datetime),
543                                ..Default::default()
544                            }),
545                        );
546                        map.insert(
547                            SmolStr::new_static("usedBy"),
548                            LexObjectProperty::String(LexString {
549                                format: Some(LexStringFormat::Did),
550                                ..Default::default()
551                            }),
552                        );
553                        map
554                    },
555                    ..Default::default()
556                }),
557            );
558            map
559        },
560        ..Default::default()
561    }
562}
563
564pub mod invite_code_use_state {
565
566    pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
567    #[allow(unused)]
568    use ::core::marker::PhantomData;
569    mod sealed {
570        pub trait Sealed {}
571    }
572    /// State trait tracking which required fields have been set
573    pub trait State: sealed::Sealed {
574        type UsedAt;
575        type UsedBy;
576    }
577    /// Empty state - all required fields are unset
578    pub struct Empty(());
579    impl sealed::Sealed for Empty {}
580    impl State for Empty {
581        type UsedAt = Unset;
582        type UsedBy = Unset;
583    }
584    ///State transition - sets the `used_at` field to Set
585    pub struct SetUsedAt<S: State = Empty>(PhantomData<fn() -> S>);
586    impl<S: State> sealed::Sealed for SetUsedAt<S> {}
587    impl<S: State> State for SetUsedAt<S> {
588        type UsedAt = Set<members::used_at>;
589        type UsedBy = S::UsedBy;
590    }
591    ///State transition - sets the `used_by` field to Set
592    pub struct SetUsedBy<S: State = Empty>(PhantomData<fn() -> S>);
593    impl<S: State> sealed::Sealed for SetUsedBy<S> {}
594    impl<S: State> State for SetUsedBy<S> {
595        type UsedAt = S::UsedAt;
596        type UsedBy = Set<members::used_by>;
597    }
598    /// Marker types for field names
599    #[allow(non_camel_case_types)]
600    pub mod members {
601        ///Marker type for the `used_at` field
602        pub struct used_at(());
603        ///Marker type for the `used_by` field
604        pub struct used_by(());
605    }
606}
607
608/// Builder for constructing an instance of this type
609pub struct InviteCodeUseBuilder<'a, S: invite_code_use_state::State> {
610    _state: PhantomData<fn() -> S>,
611    _fields: (Option<Datetime>, Option<Did<'a>>),
612    _lifetime: PhantomData<&'a ()>,
613}
614
615impl<'a> InviteCodeUse<'a> {
616    /// Create a new builder for this type
617    pub fn new() -> InviteCodeUseBuilder<'a, invite_code_use_state::Empty> {
618        InviteCodeUseBuilder::new()
619    }
620}
621
622impl<'a> InviteCodeUseBuilder<'a, invite_code_use_state::Empty> {
623    /// Create a new builder with all fields unset
624    pub fn new() -> Self {
625        InviteCodeUseBuilder {
626            _state: PhantomData,
627            _fields: (None, None),
628            _lifetime: PhantomData,
629        }
630    }
631}
632
633impl<'a, S> InviteCodeUseBuilder<'a, S>
634where
635    S: invite_code_use_state::State,
636    S::UsedAt: invite_code_use_state::IsUnset,
637{
638    /// Set the `usedAt` field (required)
639    pub fn used_at(
640        mut self,
641        value: impl Into<Datetime>,
642    ) -> InviteCodeUseBuilder<'a, invite_code_use_state::SetUsedAt<S>> {
643        self._fields.0 = Option::Some(value.into());
644        InviteCodeUseBuilder {
645            _state: PhantomData,
646            _fields: self._fields,
647            _lifetime: PhantomData,
648        }
649    }
650}
651
652impl<'a, S> InviteCodeUseBuilder<'a, S>
653where
654    S: invite_code_use_state::State,
655    S::UsedBy: invite_code_use_state::IsUnset,
656{
657    /// Set the `usedBy` field (required)
658    pub fn used_by(
659        mut self,
660        value: impl Into<Did<'a>>,
661    ) -> InviteCodeUseBuilder<'a, invite_code_use_state::SetUsedBy<S>> {
662        self._fields.1 = Option::Some(value.into());
663        InviteCodeUseBuilder {
664            _state: PhantomData,
665            _fields: self._fields,
666            _lifetime: PhantomData,
667        }
668    }
669}
670
671impl<'a, S> InviteCodeUseBuilder<'a, S>
672where
673    S: invite_code_use_state::State,
674    S::UsedAt: invite_code_use_state::IsSet,
675    S::UsedBy: invite_code_use_state::IsSet,
676{
677    /// Build the final struct
678    pub fn build(self) -> InviteCodeUse<'a> {
679        InviteCodeUse {
680            used_at: self._fields.0.unwrap(),
681            used_by: self._fields.1.unwrap(),
682            extra_data: Default::default(),
683        }
684    }
685    /// Build the final struct with custom extra_data
686    pub fn build_with_data(
687        self,
688        extra_data: BTreeMap<
689            jacquard_common::deps::smol_str::SmolStr,
690            jacquard_common::types::value::Data<'a>,
691        >,
692    ) -> InviteCodeUse<'a> {
693        InviteCodeUse {
694            used_at: self._fields.0.unwrap(),
695            used_by: self._fields.1.unwrap(),
696            extra_data: Some(extra_data),
697        }
698    }
699}
jacquard_api/com_atproto/server.rs

jacquard_api/com_atproto/
server.rs
