nonbinary.computer
atproto blogging
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: std::option::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 CreatedAt;
40 type Name;
41 type Password;
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 CreatedAt = Unset;
48 type Name = Unset;
49 type Password = Unset;
50 }
51 ///State transition - sets the `created_at` field to Set
52 pub struct SetCreatedAt<S: State = Empty>(PhantomData<fn() -> S>);
53 impl<S: State> sealed::Sealed for SetCreatedAt<S> {}
54 impl<S: State> State for SetCreatedAt<S> {
55 type CreatedAt = Set<members::created_at>;
56 type Name = S::Name;
57 type Password = S::Password;
58 }
59 ///State transition - sets the `name` field to Set
60 pub struct SetName<S: State = Empty>(PhantomData<fn() -> S>);
61 impl<S: State> sealed::Sealed for SetName<S> {}
62 impl<S: State> State for SetName<S> {
63 type CreatedAt = S::CreatedAt;
64 type Name = Set<members::name>;
65 type Password = S::Password;
66 }
67 ///State transition - sets the `password` field to Set
68 pub struct SetPassword<S: State = Empty>(PhantomData<fn() -> S>);
69 impl<S: State> sealed::Sealed for SetPassword<S> {}
70 impl<S: State> State for SetPassword<S> {
71 type CreatedAt = S::CreatedAt;
72 type Name = S::Name;
73 type Password = Set<members::password>;
74 }
75 /// Marker types for field names
76 #[allow(non_camel_case_types)]
77 pub mod members {
78 ///Marker type for the `created_at` field
79 pub struct created_at(());
80 ///Marker type for the `name` field
81 pub struct name(());
82 ///Marker type for the `password` field
83 pub struct password(());
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::CreatedAt: app_password_state::IsSet,
191 S::Name: app_password_state::IsSet,
192 S::Password: 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 = ::alloc::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 = ::alloc::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 = ::alloc::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 ) -> ::core::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<jacquard_common::CowStr<'a>>),
449}
450
451impl core::fmt::Display for CreateAppPasswordError<'_> {
452 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::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}