jacquard_api/com_atproto/server/
create_app_password.rs

1// @generated by jacquard-lexicon. DO NOT EDIT.
2//
3// Lexicon: com.atproto.server.createAppPassword
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 AppPassword<'a> {
20    pub created_at: jacquard_common::types::string::Datetime,
21    #[serde(borrow)]
22    pub name: jacquard_common::CowStr<'a>,
23    #[serde(borrow)]
24    pub password: jacquard_common::CowStr<'a>,
25    #[serde(skip_serializing_if = "std::option::Option::is_none")]
26    pub privileged: Option<bool>,
27}
28
29pub mod app_password_state {
30
31    pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
32    #[allow(unused)]
33    use ::core::marker::PhantomData;
34    mod sealed {
35        pub trait Sealed {}
36    }
37    /// State trait tracking which required fields have been set
38    pub trait State: sealed::Sealed {
39        type Name;
40        type Password;
41        type CreatedAt;
42    }
43    /// Empty state - all required fields are unset
44    pub struct Empty(());
45    impl sealed::Sealed for Empty {}
46    impl State for Empty {
47        type Name = Unset;
48        type Password = Unset;
49        type CreatedAt = Unset;
50    }
51    ///State transition - sets the `name` field to Set
52    pub struct SetName<S: State = Empty>(PhantomData<fn() -> S>);
53    impl<S: State> sealed::Sealed for SetName<S> {}
54    impl<S: State> State for SetName<S> {
55        type Name = Set<members::name>;
56        type Password = S::Password;
57        type CreatedAt = S::CreatedAt;
58    }
59    ///State transition - sets the `password` field to Set
60    pub struct SetPassword<S: State = Empty>(PhantomData<fn() -> S>);
61    impl<S: State> sealed::Sealed for SetPassword<S> {}
62    impl<S: State> State for SetPassword<S> {
63        type Name = S::Name;
64        type Password = Set<members::password>;
65        type CreatedAt = S::CreatedAt;
66    }
67    ///State transition - sets the `created_at` field to Set
68    pub struct SetCreatedAt<S: State = Empty>(PhantomData<fn() -> S>);
69    impl<S: State> sealed::Sealed for SetCreatedAt<S> {}
70    impl<S: State> State for SetCreatedAt<S> {
71        type Name = S::Name;
72        type Password = S::Password;
73        type CreatedAt = Set<members::created_at>;
74    }
75    /// Marker types for field names
76    #[allow(non_camel_case_types)]
77    pub mod members {
78        ///Marker type for the `name` field
79        pub struct name(());
80        ///Marker type for the `password` field
81        pub struct password(());
82        ///Marker type for the `created_at` field
83        pub struct created_at(());
84    }
85}
86
87/// Builder for constructing an instance of this type
88pub struct AppPasswordBuilder<'a, S: app_password_state::State> {
89    _phantom_state: ::core::marker::PhantomData<fn() -> S>,
90    __unsafe_private_named: (
91        ::core::option::Option<jacquard_common::types::string::Datetime>,
92        ::core::option::Option<jacquard_common::CowStr<'a>>,
93        ::core::option::Option<jacquard_common::CowStr<'a>>,
94        ::core::option::Option<bool>,
95    ),
96    _phantom: ::core::marker::PhantomData<&'a ()>,
97}
98
99impl<'a> AppPassword<'a> {
100    /// Create a new builder for this type
101    pub fn new() -> AppPasswordBuilder<'a, app_password_state::Empty> {
102        AppPasswordBuilder::new()
103    }
104}
105
106impl<'a> AppPasswordBuilder<'a, app_password_state::Empty> {
107    /// Create a new builder with all fields unset
108    pub fn new() -> Self {
109        AppPasswordBuilder {
110            _phantom_state: ::core::marker::PhantomData,
111            __unsafe_private_named: (None, None, None, None),
112            _phantom: ::core::marker::PhantomData,
113        }
114    }
115}
116
117impl<'a, S> AppPasswordBuilder<'a, S>
118where
119    S: app_password_state::State,
120    S::CreatedAt: app_password_state::IsUnset,
121{
122    /// Set the `createdAt` field (required)
123    pub fn created_at(
124        mut self,
125        value: impl Into<jacquard_common::types::string::Datetime>,
126    ) -> AppPasswordBuilder<'a, app_password_state::SetCreatedAt<S>> {
127        self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
128        AppPasswordBuilder {
129            _phantom_state: ::core::marker::PhantomData,
130            __unsafe_private_named: self.__unsafe_private_named,
131            _phantom: ::core::marker::PhantomData,
132        }
133    }
134}
135
136impl<'a, S> AppPasswordBuilder<'a, S>
137where
138    S: app_password_state::State,
139    S::Name: app_password_state::IsUnset,
140{
141    /// Set the `name` field (required)
142    pub fn name(
143        mut self,
144        value: impl Into<jacquard_common::CowStr<'a>>,
145    ) -> AppPasswordBuilder<'a, app_password_state::SetName<S>> {
146        self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
147        AppPasswordBuilder {
148            _phantom_state: ::core::marker::PhantomData,
149            __unsafe_private_named: self.__unsafe_private_named,
150            _phantom: ::core::marker::PhantomData,
151        }
152    }
153}
154
155impl<'a, S> AppPasswordBuilder<'a, S>
156where
157    S: app_password_state::State,
158    S::Password: app_password_state::IsUnset,
159{
160    /// Set the `password` field (required)
161    pub fn password(
162        mut self,
163        value: impl Into<jacquard_common::CowStr<'a>>,
164    ) -> AppPasswordBuilder<'a, app_password_state::SetPassword<S>> {
165        self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into());
166        AppPasswordBuilder {
167            _phantom_state: ::core::marker::PhantomData,
168            __unsafe_private_named: self.__unsafe_private_named,
169            _phantom: ::core::marker::PhantomData,
170        }
171    }
172}
173
174impl<'a, S: app_password_state::State> AppPasswordBuilder<'a, S> {
175    /// Set the `privileged` field (optional)
176    pub fn privileged(mut self, value: impl Into<Option<bool>>) -> Self {
177        self.__unsafe_private_named.3 = value.into();
178        self
179    }
180    /// Set the `privileged` field to an Option value (optional)
181    pub fn maybe_privileged(mut self, value: Option<bool>) -> Self {
182        self.__unsafe_private_named.3 = value;
183        self
184    }
185}
186
187impl<'a, S> AppPasswordBuilder<'a, S>
188where
189    S: app_password_state::State,
190    S::Name: app_password_state::IsSet,
191    S::Password: app_password_state::IsSet,
192    S::CreatedAt: app_password_state::IsSet,
193{
194    /// Build the final struct
195    pub fn build(self) -> AppPassword<'a> {
196        AppPassword {
197            created_at: self.__unsafe_private_named.0.unwrap(),
198            name: self.__unsafe_private_named.1.unwrap(),
199            password: self.__unsafe_private_named.2.unwrap(),
200            privileged: self.__unsafe_private_named.3,
201            extra_data: Default::default(),
202        }
203    }
204    /// Build the final struct with custom extra_data
205    pub fn build_with_data(
206        self,
207        extra_data: std::collections::BTreeMap<
208            jacquard_common::smol_str::SmolStr,
209            jacquard_common::types::value::Data<'a>,
210        >,
211    ) -> AppPassword<'a> {
212        AppPassword {
213            created_at: self.__unsafe_private_named.0.unwrap(),
214            name: self.__unsafe_private_named.1.unwrap(),
215            password: self.__unsafe_private_named.2.unwrap(),
216            privileged: self.__unsafe_private_named.3,
217            extra_data: Some(extra_data),
218        }
219    }
220}
221
222fn lexicon_doc_com_atproto_server_createAppPassword() -> ::jacquard_lexicon::lexicon::LexiconDoc<
223    'static,
224> {
225    ::jacquard_lexicon::lexicon::LexiconDoc {
226        lexicon: ::jacquard_lexicon::lexicon::Lexicon::Lexicon1,
227        id: ::jacquard_common::CowStr::new_static(
228            "com.atproto.server.createAppPassword",
229        ),
230        revision: None,
231        description: None,
232        defs: {
233            let mut map = ::std::collections::BTreeMap::new();
234            map.insert(
235                ::jacquard_common::smol_str::SmolStr::new_static("appPassword"),
236                ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
237                    description: None,
238                    required: Some(
239                        vec![
240                            ::jacquard_common::smol_str::SmolStr::new_static("name"),
241                            ::jacquard_common::smol_str::SmolStr::new_static("password"),
242                            ::jacquard_common::smol_str::SmolStr::new_static("createdAt")
243                        ],
244                    ),
245                    nullable: None,
246                    properties: {
247                        #[allow(unused_mut)]
248                        let mut map = ::std::collections::BTreeMap::new();
249                        map.insert(
250                            ::jacquard_common::smol_str::SmolStr::new_static(
251                                "createdAt",
252                            ),
253                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
254                                description: None,
255                                format: Some(
256                                    ::jacquard_lexicon::lexicon::LexStringFormat::Datetime,
257                                ),
258                                default: None,
259                                min_length: None,
260                                max_length: None,
261                                min_graphemes: None,
262                                max_graphemes: None,
263                                r#enum: None,
264                                r#const: None,
265                                known_values: None,
266                            }),
267                        );
268                        map.insert(
269                            ::jacquard_common::smol_str::SmolStr::new_static("name"),
270                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
271                                description: None,
272                                format: None,
273                                default: None,
274                                min_length: None,
275                                max_length: None,
276                                min_graphemes: None,
277                                max_graphemes: None,
278                                r#enum: None,
279                                r#const: None,
280                                known_values: None,
281                            }),
282                        );
283                        map.insert(
284                            ::jacquard_common::smol_str::SmolStr::new_static("password"),
285                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
286                                description: None,
287                                format: None,
288                                default: None,
289                                min_length: None,
290                                max_length: None,
291                                min_graphemes: None,
292                                max_graphemes: None,
293                                r#enum: None,
294                                r#const: None,
295                                known_values: None,
296                            }),
297                        );
298                        map.insert(
299                            ::jacquard_common::smol_str::SmolStr::new_static(
300                                "privileged",
301                            ),
302                            ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
303                                description: None,
304                                default: None,
305                                r#const: None,
306                            }),
307                        );
308                        map
309                    },
310                }),
311            );
312            map.insert(
313                ::jacquard_common::smol_str::SmolStr::new_static("main"),
314                ::jacquard_lexicon::lexicon::LexUserType::XrpcProcedure(::jacquard_lexicon::lexicon::LexXrpcProcedure {
315                    description: None,
316                    parameters: None,
317                    input: Some(::jacquard_lexicon::lexicon::LexXrpcBody {
318                        description: None,
319                        encoding: ::jacquard_common::CowStr::new_static(
320                            "application/json",
321                        ),
322                        schema: Some(
323                            ::jacquard_lexicon::lexicon::LexXrpcBodySchema::Object(::jacquard_lexicon::lexicon::LexObject {
324                                description: None,
325                                required: Some(
326                                    vec![
327                                        ::jacquard_common::smol_str::SmolStr::new_static("name")
328                                    ],
329                                ),
330                                nullable: None,
331                                properties: {
332                                    #[allow(unused_mut)]
333                                    let mut map = ::std::collections::BTreeMap::new();
334                                    map.insert(
335                                        ::jacquard_common::smol_str::SmolStr::new_static("name"),
336                                        ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
337                                            description: Some(
338                                                ::jacquard_common::CowStr::new_static(
339                                                    "A short name for the App Password, to help distinguish them.",
340                                                ),
341                                            ),
342                                            format: None,
343                                            default: None,
344                                            min_length: None,
345                                            max_length: None,
346                                            min_graphemes: None,
347                                            max_graphemes: None,
348                                            r#enum: None,
349                                            r#const: None,
350                                            known_values: None,
351                                        }),
352                                    );
353                                    map.insert(
354                                        ::jacquard_common::smol_str::SmolStr::new_static(
355                                            "privileged",
356                                        ),
357                                        ::jacquard_lexicon::lexicon::LexObjectProperty::Boolean(::jacquard_lexicon::lexicon::LexBoolean {
358                                            description: None,
359                                            default: None,
360                                            r#const: None,
361                                        }),
362                                    );
363                                    map
364                                },
365                            }),
366                        ),
367                    }),
368                    output: None,
369                    errors: None,
370                }),
371            );
372            map
373        },
374    }
375}
376
377impl<'a> ::jacquard_lexicon::schema::LexiconSchema for AppPassword<'a> {
378    fn nsid() -> &'static str {
379        "com.atproto.server.createAppPassword"
380    }
381    fn def_name() -> &'static str {
382        "appPassword"
383    }
384    fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
385        lexicon_doc_com_atproto_server_createAppPassword()
386    }
387    fn validate(
388        &self,
389    ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
390        Ok(())
391    }
392}
393
394#[jacquard_derive::lexicon]
395#[derive(
396    serde::Serialize,
397    serde::Deserialize,
398    Debug,
399    Clone,
400    PartialEq,
401    Eq,
402    jacquard_derive::IntoStatic,
403    Default
404)]
405#[serde(rename_all = "camelCase")]
406pub struct CreateAppPassword<'a> {
407    /// A short name for the App Password, to help distinguish them.
408    #[serde(borrow)]
409    pub name: jacquard_common::CowStr<'a>,
410    /// If an app password has 'privileged' access to possibly sensitive account state. Meant for use with trusted clients.
411    #[serde(skip_serializing_if = "std::option::Option::is_none")]
412    pub privileged: std::option::Option<bool>,
413}
414
415#[jacquard_derive::lexicon]
416#[derive(
417    serde::Serialize,
418    serde::Deserialize,
419    Debug,
420    Clone,
421    PartialEq,
422    Eq,
423    jacquard_derive::IntoStatic
424)]
425#[serde(rename_all = "camelCase")]
426pub struct CreateAppPasswordOutput<'a> {
427    #[serde(flatten)]
428    #[serde(borrow)]
429    pub value: jacquard_common::types::value::Data<'a>,
430}
431
432#[jacquard_derive::open_union]
433#[derive(
434    serde::Serialize,
435    serde::Deserialize,
436    Debug,
437    Clone,
438    PartialEq,
439    Eq,
440    thiserror::Error,
441    miette::Diagnostic,
442    jacquard_derive::IntoStatic
443)]
444#[serde(tag = "error", content = "message")]
445#[serde(bound(deserialize = "'de: 'a"))]
446pub enum CreateAppPasswordError<'a> {
447    #[serde(rename = "AccountTakedown")]
448    AccountTakedown(std::option::Option<String>),
449}
450
451impl std::fmt::Display for CreateAppPasswordError<'_> {
452    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
453        match self {
454            Self::AccountTakedown(msg) => {
455                write!(f, "AccountTakedown")?;
456                if let Some(msg) = msg {
457                    write!(f, ": {}", msg)?;
458                }
459                Ok(())
460            }
461            Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
462        }
463    }
464}
465
466/// Response type for
467///com.atproto.server.createAppPassword
468pub struct CreateAppPasswordResponse;
469impl jacquard_common::xrpc::XrpcResp for CreateAppPasswordResponse {
470    const NSID: &'static str = "com.atproto.server.createAppPassword";
471    const ENCODING: &'static str = "application/json";
472    type Output<'de> = CreateAppPasswordOutput<'de>;
473    type Err<'de> = CreateAppPasswordError<'de>;
474}
475
476impl<'a> jacquard_common::xrpc::XrpcRequest for CreateAppPassword<'a> {
477    const NSID: &'static str = "com.atproto.server.createAppPassword";
478    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
479        "application/json",
480    );
481    type Response = CreateAppPasswordResponse;
482}
483
484/// Endpoint type for
485///com.atproto.server.createAppPassword
486pub struct CreateAppPasswordRequest;
487impl jacquard_common::xrpc::XrpcEndpoint for CreateAppPasswordRequest {
488    const PATH: &'static str = "/xrpc/com.atproto.server.createAppPassword";
489    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
490        "application/json",
491    );
492    type Request<'de> = CreateAppPassword<'de>;
493    type Response = CreateAppPasswordResponse;
494}
jacquard_api/com_atproto/server/create_app_password.rs

jacquard_api/com_atproto/server/
create_app_password.rs
