nonbinary.computer
atproto blogging
1// @generated by jacquard-lexicon. DO NOT EDIT.
2//
3// Lexicon: com.atproto.temp.checkHandleAvailability
4//
5// This file was automatically generated from Lexicon schemas.
6// Any manual changes will be overwritten on the next regeneration.
7
8#[derive(
9 serde::Serialize,
10 serde::Deserialize,
11 Debug,
12 Clone,
13 PartialEq,
14 Eq,
15 jacquard_derive::IntoStatic
16)]
17#[serde(rename_all = "camelCase")]
18pub struct CheckHandleAvailability<'a> {
19 #[serde(skip_serializing_if = "std::option::Option::is_none")]
20 pub birth_date: std::option::Option<jacquard_common::types::string::Datetime>,
21 #[serde(skip_serializing_if = "std::option::Option::is_none")]
22 #[serde(borrow)]
23 pub email: std::option::Option<jacquard_common::CowStr<'a>>,
24 #[serde(borrow)]
25 pub handle: jacquard_common::types::string::Handle<'a>,
26}
27
28pub mod check_handle_availability_state {
29
30 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
31 #[allow(unused)]
32 use ::core::marker::PhantomData;
33 mod sealed {
34 pub trait Sealed {}
35 }
36 /// State trait tracking which required fields have been set
37 pub trait State: sealed::Sealed {
38 type Handle;
39 }
40 /// Empty state - all required fields are unset
41 pub struct Empty(());
42 impl sealed::Sealed for Empty {}
43 impl State for Empty {
44 type Handle = Unset;
45 }
46 ///State transition - sets the `handle` field to Set
47 pub struct SetHandle<S: State = Empty>(PhantomData<fn() -> S>);
48 impl<S: State> sealed::Sealed for SetHandle<S> {}
49 impl<S: State> State for SetHandle<S> {
50 type Handle = Set<members::handle>;
51 }
52 /// Marker types for field names
53 #[allow(non_camel_case_types)]
54 pub mod members {
55 ///Marker type for the `handle` field
56 pub struct handle(());
57 }
58}
59
60/// Builder for constructing an instance of this type
61pub struct CheckHandleAvailabilityBuilder<
62 'a,
63 S: check_handle_availability_state::State,
64> {
65 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
66 __unsafe_private_named: (
67 ::core::option::Option<jacquard_common::types::string::Datetime>,
68 ::core::option::Option<jacquard_common::CowStr<'a>>,
69 ::core::option::Option<jacquard_common::types::string::Handle<'a>>,
70 ),
71 _phantom: ::core::marker::PhantomData<&'a ()>,
72}
73
74impl<'a> CheckHandleAvailability<'a> {
75 /// Create a new builder for this type
76 pub fn new() -> CheckHandleAvailabilityBuilder<
77 'a,
78 check_handle_availability_state::Empty,
79 > {
80 CheckHandleAvailabilityBuilder::new()
81 }
82}
83
84impl<'a> CheckHandleAvailabilityBuilder<'a, check_handle_availability_state::Empty> {
85 /// Create a new builder with all fields unset
86 pub fn new() -> Self {
87 CheckHandleAvailabilityBuilder {
88 _phantom_state: ::core::marker::PhantomData,
89 __unsafe_private_named: (None, None, None),
90 _phantom: ::core::marker::PhantomData,
91 }
92 }
93}
94
95impl<
96 'a,
97 S: check_handle_availability_state::State,
98> CheckHandleAvailabilityBuilder<'a, S> {
99 /// Set the `birthDate` field (optional)
100 pub fn birth_date(
101 mut self,
102 value: impl Into<Option<jacquard_common::types::string::Datetime>>,
103 ) -> Self {
104 self.__unsafe_private_named.0 = value.into();
105 self
106 }
107 /// Set the `birthDate` field to an Option value (optional)
108 pub fn maybe_birth_date(
109 mut self,
110 value: Option<jacquard_common::types::string::Datetime>,
111 ) -> Self {
112 self.__unsafe_private_named.0 = value;
113 self
114 }
115}
116
117impl<
118 'a,
119 S: check_handle_availability_state::State,
120> CheckHandleAvailabilityBuilder<'a, S> {
121 /// Set the `email` field (optional)
122 pub fn email(
123 mut self,
124 value: impl Into<Option<jacquard_common::CowStr<'a>>>,
125 ) -> Self {
126 self.__unsafe_private_named.1 = value.into();
127 self
128 }
129 /// Set the `email` field to an Option value (optional)
130 pub fn maybe_email(mut self, value: Option<jacquard_common::CowStr<'a>>) -> Self {
131 self.__unsafe_private_named.1 = value;
132 self
133 }
134}
135
136impl<'a, S> CheckHandleAvailabilityBuilder<'a, S>
137where
138 S: check_handle_availability_state::State,
139 S::Handle: check_handle_availability_state::IsUnset,
140{
141 /// Set the `handle` field (required)
142 pub fn handle(
143 mut self,
144 value: impl Into<jacquard_common::types::string::Handle<'a>>,
145 ) -> CheckHandleAvailabilityBuilder<
146 'a,
147 check_handle_availability_state::SetHandle<S>,
148 > {
149 self.__unsafe_private_named.2 = ::core::option::Option::Some(value.into());
150 CheckHandleAvailabilityBuilder {
151 _phantom_state: ::core::marker::PhantomData,
152 __unsafe_private_named: self.__unsafe_private_named,
153 _phantom: ::core::marker::PhantomData,
154 }
155 }
156}
157
158impl<'a, S> CheckHandleAvailabilityBuilder<'a, S>
159where
160 S: check_handle_availability_state::State,
161 S::Handle: check_handle_availability_state::IsSet,
162{
163 /// Build the final struct
164 pub fn build(self) -> CheckHandleAvailability<'a> {
165 CheckHandleAvailability {
166 birth_date: self.__unsafe_private_named.0,
167 email: self.__unsafe_private_named.1,
168 handle: self.__unsafe_private_named.2.unwrap(),
169 }
170 }
171}
172
173#[jacquard_derive::lexicon]
174#[derive(
175 serde::Serialize,
176 serde::Deserialize,
177 Debug,
178 Clone,
179 PartialEq,
180 Eq,
181 jacquard_derive::IntoStatic
182)]
183#[serde(rename_all = "camelCase")]
184pub struct CheckHandleAvailabilityOutput<'a> {
185 /// Echo of the input handle.
186 #[serde(borrow)]
187 pub handle: jacquard_common::types::string::Handle<'a>,
188 #[serde(borrow)]
189 pub result: CheckHandleAvailabilityOutputResult<'a>,
190}
191
192#[jacquard_derive::open_union]
193#[derive(
194 serde::Serialize,
195 serde::Deserialize,
196 Debug,
197 Clone,
198 PartialEq,
199 Eq,
200 jacquard_derive::IntoStatic
201)]
202#[serde(tag = "$type")]
203#[serde(bound(deserialize = "'de: 'a"))]
204pub enum CheckHandleAvailabilityOutputResult<'a> {
205 #[serde(rename = "com.atproto.temp.checkHandleAvailability#resultAvailable")]
206 ResultAvailable(
207 Box<crate::com_atproto::temp::check_handle_availability::ResultAvailable<'a>>,
208 ),
209 #[serde(rename = "com.atproto.temp.checkHandleAvailability#resultUnavailable")]
210 ResultUnavailable(
211 Box<crate::com_atproto::temp::check_handle_availability::ResultUnavailable<'a>>,
212 ),
213}
214
215#[jacquard_derive::open_union]
216#[derive(
217 serde::Serialize,
218 serde::Deserialize,
219 Debug,
220 Clone,
221 PartialEq,
222 Eq,
223 thiserror::Error,
224 miette::Diagnostic,
225 jacquard_derive::IntoStatic
226)]
227#[serde(tag = "error", content = "message")]
228#[serde(bound(deserialize = "'de: 'a"))]
229pub enum CheckHandleAvailabilityError<'a> {
230 /// An invalid email was provided.
231 #[serde(rename = "InvalidEmail")]
232 InvalidEmail(std::option::Option<jacquard_common::CowStr<'a>>),
233}
234
235impl core::fmt::Display for CheckHandleAvailabilityError<'_> {
236 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
237 match self {
238 Self::InvalidEmail(msg) => {
239 write!(f, "InvalidEmail")?;
240 if let Some(msg) = msg {
241 write!(f, ": {}", msg)?;
242 }
243 Ok(())
244 }
245 Self::Unknown(err) => write!(f, "Unknown error: {:?}", err),
246 }
247 }
248}
249
250/// Response type for
251///com.atproto.temp.checkHandleAvailability
252pub struct CheckHandleAvailabilityResponse;
253impl jacquard_common::xrpc::XrpcResp for CheckHandleAvailabilityResponse {
254 const NSID: &'static str = "com.atproto.temp.checkHandleAvailability";
255 const ENCODING: &'static str = "application/json";
256 type Output<'de> = CheckHandleAvailabilityOutput<'de>;
257 type Err<'de> = CheckHandleAvailabilityError<'de>;
258}
259
260impl<'a> jacquard_common::xrpc::XrpcRequest for CheckHandleAvailability<'a> {
261 const NSID: &'static str = "com.atproto.temp.checkHandleAvailability";
262 const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
263 type Response = CheckHandleAvailabilityResponse;
264}
265
266/// Endpoint type for
267///com.atproto.temp.checkHandleAvailability
268pub struct CheckHandleAvailabilityRequest;
269impl jacquard_common::xrpc::XrpcEndpoint for CheckHandleAvailabilityRequest {
270 const PATH: &'static str = "/xrpc/com.atproto.temp.checkHandleAvailability";
271 const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
272 type Request<'de> = CheckHandleAvailability<'de>;
273 type Response = CheckHandleAvailabilityResponse;
274}
275
276/// Indicates the provided handle is available.
277#[jacquard_derive::lexicon]
278#[derive(
279 serde::Serialize,
280 serde::Deserialize,
281 Debug,
282 Clone,
283 PartialEq,
284 Eq,
285 jacquard_derive::IntoStatic,
286 Default
287)]
288#[serde(rename_all = "camelCase")]
289pub struct ResultAvailable<'a> {}
290fn lexicon_doc_com_atproto_temp_checkHandleAvailability() -> ::jacquard_lexicon::lexicon::LexiconDoc<
291 'static,
292> {
293 ::jacquard_lexicon::lexicon::LexiconDoc {
294 lexicon: ::jacquard_lexicon::lexicon::Lexicon::Lexicon1,
295 id: ::jacquard_common::CowStr::new_static(
296 "com.atproto.temp.checkHandleAvailability",
297 ),
298 revision: None,
299 description: None,
300 defs: {
301 let mut map = ::alloc::collections::BTreeMap::new();
302 map.insert(
303 ::jacquard_common::smol_str::SmolStr::new_static("main"),
304 ::jacquard_lexicon::lexicon::LexUserType::XrpcQuery(::jacquard_lexicon::lexicon::LexXrpcQuery {
305 description: None,
306 parameters: Some(
307 ::jacquard_lexicon::lexicon::LexXrpcQueryParameter::Params(::jacquard_lexicon::lexicon::LexXrpcParameters {
308 description: None,
309 required: Some(
310 vec![
311 ::jacquard_common::smol_str::SmolStr::new_static("handle")
312 ],
313 ),
314 properties: {
315 #[allow(unused_mut)]
316 let mut map = ::alloc::collections::BTreeMap::new();
317 map.insert(
318 ::jacquard_common::smol_str::SmolStr::new_static(
319 "birthDate",
320 ),
321 ::jacquard_lexicon::lexicon::LexXrpcParametersProperty::String(::jacquard_lexicon::lexicon::LexString {
322 description: Some(
323 ::jacquard_common::CowStr::new_static(
324 "User-provided birth date. Might be used to build handle suggestions.",
325 ),
326 ),
327 format: Some(
328 ::jacquard_lexicon::lexicon::LexStringFormat::Datetime,
329 ),
330 default: None,
331 min_length: None,
332 max_length: None,
333 min_graphemes: None,
334 max_graphemes: None,
335 r#enum: None,
336 r#const: None,
337 known_values: None,
338 }),
339 );
340 map.insert(
341 ::jacquard_common::smol_str::SmolStr::new_static("email"),
342 ::jacquard_lexicon::lexicon::LexXrpcParametersProperty::String(::jacquard_lexicon::lexicon::LexString {
343 description: Some(
344 ::jacquard_common::CowStr::new_static(
345 "User-provided email. Might be used to build handle suggestions.",
346 ),
347 ),
348 format: None,
349 default: None,
350 min_length: None,
351 max_length: None,
352 min_graphemes: None,
353 max_graphemes: None,
354 r#enum: None,
355 r#const: None,
356 known_values: None,
357 }),
358 );
359 map.insert(
360 ::jacquard_common::smol_str::SmolStr::new_static("handle"),
361 ::jacquard_lexicon::lexicon::LexXrpcParametersProperty::String(::jacquard_lexicon::lexicon::LexString {
362 description: Some(
363 ::jacquard_common::CowStr::new_static(
364 "Tentative handle. Will be checked for availability or used to build handle suggestions.",
365 ),
366 ),
367 format: Some(
368 ::jacquard_lexicon::lexicon::LexStringFormat::Handle,
369 ),
370 default: None,
371 min_length: None,
372 max_length: None,
373 min_graphemes: None,
374 max_graphemes: None,
375 r#enum: None,
376 r#const: None,
377 known_values: None,
378 }),
379 );
380 map
381 },
382 }),
383 ),
384 output: None,
385 errors: None,
386 }),
387 );
388 map.insert(
389 ::jacquard_common::smol_str::SmolStr::new_static("resultAvailable"),
390 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
391 description: Some(
392 ::jacquard_common::CowStr::new_static(
393 "Indicates the provided handle is available.",
394 ),
395 ),
396 required: None,
397 nullable: None,
398 properties: {
399 #[allow(unused_mut)]
400 let mut map = ::alloc::collections::BTreeMap::new();
401 map
402 },
403 }),
404 );
405 map.insert(
406 ::jacquard_common::smol_str::SmolStr::new_static("resultUnavailable"),
407 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
408 description: Some(
409 ::jacquard_common::CowStr::new_static(
410 "Indicates the provided handle is unavailable and gives suggestions of available handles.",
411 ),
412 ),
413 required: Some(
414 vec![
415 ::jacquard_common::smol_str::SmolStr::new_static("suggestions")
416 ],
417 ),
418 nullable: None,
419 properties: {
420 #[allow(unused_mut)]
421 let mut map = ::alloc::collections::BTreeMap::new();
422 map.insert(
423 ::jacquard_common::smol_str::SmolStr::new_static(
424 "suggestions",
425 ),
426 ::jacquard_lexicon::lexicon::LexObjectProperty::Array(::jacquard_lexicon::lexicon::LexArray {
427 description: Some(
428 ::jacquard_common::CowStr::new_static(
429 "List of suggested handles based on the provided inputs.",
430 ),
431 ),
432 items: ::jacquard_lexicon::lexicon::LexArrayItem::Ref(::jacquard_lexicon::lexicon::LexRef {
433 description: None,
434 r#ref: ::jacquard_common::CowStr::new_static("#suggestion"),
435 }),
436 min_length: None,
437 max_length: None,
438 }),
439 );
440 map
441 },
442 }),
443 );
444 map.insert(
445 ::jacquard_common::smol_str::SmolStr::new_static("suggestion"),
446 ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
447 description: None,
448 required: Some(
449 vec![
450 ::jacquard_common::smol_str::SmolStr::new_static("handle"),
451 ::jacquard_common::smol_str::SmolStr::new_static("method")
452 ],
453 ),
454 nullable: None,
455 properties: {
456 #[allow(unused_mut)]
457 let mut map = ::alloc::collections::BTreeMap::new();
458 map.insert(
459 ::jacquard_common::smol_str::SmolStr::new_static("handle"),
460 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
461 description: None,
462 format: Some(
463 ::jacquard_lexicon::lexicon::LexStringFormat::Handle,
464 ),
465 default: None,
466 min_length: None,
467 max_length: None,
468 min_graphemes: None,
469 max_graphemes: None,
470 r#enum: None,
471 r#const: None,
472 known_values: None,
473 }),
474 );
475 map.insert(
476 ::jacquard_common::smol_str::SmolStr::new_static("method"),
477 ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
478 description: Some(
479 ::jacquard_common::CowStr::new_static(
480 "Method used to build this suggestion. Should be considered opaque to clients. Can be used for metrics.",
481 ),
482 ),
483 format: None,
484 default: None,
485 min_length: None,
486 max_length: None,
487 min_graphemes: None,
488 max_graphemes: None,
489 r#enum: None,
490 r#const: None,
491 known_values: None,
492 }),
493 );
494 map
495 },
496 }),
497 );
498 map
499 },
500 }
501}
502
503impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ResultAvailable<'a> {
504 fn nsid() -> &'static str {
505 "com.atproto.temp.checkHandleAvailability"
506 }
507 fn def_name() -> &'static str {
508 "resultAvailable"
509 }
510 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
511 lexicon_doc_com_atproto_temp_checkHandleAvailability()
512 }
513 fn validate(
514 &self,
515 ) -> ::core::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
516 Ok(())
517 }
518}
519
520/// Indicates the provided handle is unavailable and gives suggestions of available handles.
521#[jacquard_derive::lexicon]
522#[derive(
523 serde::Serialize,
524 serde::Deserialize,
525 Debug,
526 Clone,
527 PartialEq,
528 Eq,
529 jacquard_derive::IntoStatic
530)]
531#[serde(rename_all = "camelCase")]
532pub struct ResultUnavailable<'a> {
533 /// List of suggested handles based on the provided inputs.
534 #[serde(borrow)]
535 pub suggestions: Vec<
536 crate::com_atproto::temp::check_handle_availability::Suggestion<'a>,
537 >,
538}
539
540pub mod result_unavailable_state {
541
542 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
543 #[allow(unused)]
544 use ::core::marker::PhantomData;
545 mod sealed {
546 pub trait Sealed {}
547 }
548 /// State trait tracking which required fields have been set
549 pub trait State: sealed::Sealed {
550 type Suggestions;
551 }
552 /// Empty state - all required fields are unset
553 pub struct Empty(());
554 impl sealed::Sealed for Empty {}
555 impl State for Empty {
556 type Suggestions = Unset;
557 }
558 ///State transition - sets the `suggestions` field to Set
559 pub struct SetSuggestions<S: State = Empty>(PhantomData<fn() -> S>);
560 impl<S: State> sealed::Sealed for SetSuggestions<S> {}
561 impl<S: State> State for SetSuggestions<S> {
562 type Suggestions = Set<members::suggestions>;
563 }
564 /// Marker types for field names
565 #[allow(non_camel_case_types)]
566 pub mod members {
567 ///Marker type for the `suggestions` field
568 pub struct suggestions(());
569 }
570}
571
572/// Builder for constructing an instance of this type
573pub struct ResultUnavailableBuilder<'a, S: result_unavailable_state::State> {
574 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
575 __unsafe_private_named: (
576 ::core::option::Option<
577 Vec<crate::com_atproto::temp::check_handle_availability::Suggestion<'a>>,
578 >,
579 ),
580 _phantom: ::core::marker::PhantomData<&'a ()>,
581}
582
583impl<'a> ResultUnavailable<'a> {
584 /// Create a new builder for this type
585 pub fn new() -> ResultUnavailableBuilder<'a, result_unavailable_state::Empty> {
586 ResultUnavailableBuilder::new()
587 }
588}
589
590impl<'a> ResultUnavailableBuilder<'a, result_unavailable_state::Empty> {
591 /// Create a new builder with all fields unset
592 pub fn new() -> Self {
593 ResultUnavailableBuilder {
594 _phantom_state: ::core::marker::PhantomData,
595 __unsafe_private_named: (None,),
596 _phantom: ::core::marker::PhantomData,
597 }
598 }
599}
600
601impl<'a, S> ResultUnavailableBuilder<'a, S>
602where
603 S: result_unavailable_state::State,
604 S::Suggestions: result_unavailable_state::IsUnset,
605{
606 /// Set the `suggestions` field (required)
607 pub fn suggestions(
608 mut self,
609 value: impl Into<
610 Vec<crate::com_atproto::temp::check_handle_availability::Suggestion<'a>>,
611 >,
612 ) -> ResultUnavailableBuilder<'a, result_unavailable_state::SetSuggestions<S>> {
613 self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
614 ResultUnavailableBuilder {
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> ResultUnavailableBuilder<'a, S>
623where
624 S: result_unavailable_state::State,
625 S::Suggestions: result_unavailable_state::IsSet,
626{
627 /// Build the final struct
628 pub fn build(self) -> ResultUnavailable<'a> {
629 ResultUnavailable {
630 suggestions: 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 ) -> ResultUnavailable<'a> {
642 ResultUnavailable {
643 suggestions: self.__unsafe_private_named.0.unwrap(),
644 extra_data: Some(extra_data),
645 }
646 }
647}
648
649impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ResultUnavailable<'a> {
650 fn nsid() -> &'static str {
651 "com.atproto.temp.checkHandleAvailability"
652 }
653 fn def_name() -> &'static str {
654 "resultUnavailable"
655 }
656 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
657 lexicon_doc_com_atproto_temp_checkHandleAvailability()
658 }
659 fn validate(
660 &self,
661 ) -> ::core::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
662 Ok(())
663 }
664}
665
666#[jacquard_derive::lexicon]
667#[derive(
668 serde::Serialize,
669 serde::Deserialize,
670 Debug,
671 Clone,
672 PartialEq,
673 Eq,
674 jacquard_derive::IntoStatic
675)]
676#[serde(rename_all = "camelCase")]
677pub struct Suggestion<'a> {
678 #[serde(borrow)]
679 pub handle: jacquard_common::types::string::Handle<'a>,
680 /// Method used to build this suggestion. Should be considered opaque to clients. Can be used for metrics.
681 #[serde(borrow)]
682 pub method: jacquard_common::CowStr<'a>,
683}
684
685pub mod suggestion_state {
686
687 pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
688 #[allow(unused)]
689 use ::core::marker::PhantomData;
690 mod sealed {
691 pub trait Sealed {}
692 }
693 /// State trait tracking which required fields have been set
694 pub trait State: sealed::Sealed {
695 type Handle;
696 type Method;
697 }
698 /// Empty state - all required fields are unset
699 pub struct Empty(());
700 impl sealed::Sealed for Empty {}
701 impl State for Empty {
702 type Handle = Unset;
703 type Method = Unset;
704 }
705 ///State transition - sets the `handle` field to Set
706 pub struct SetHandle<S: State = Empty>(PhantomData<fn() -> S>);
707 impl<S: State> sealed::Sealed for SetHandle<S> {}
708 impl<S: State> State for SetHandle<S> {
709 type Handle = Set<members::handle>;
710 type Method = S::Method;
711 }
712 ///State transition - sets the `method` field to Set
713 pub struct SetMethod<S: State = Empty>(PhantomData<fn() -> S>);
714 impl<S: State> sealed::Sealed for SetMethod<S> {}
715 impl<S: State> State for SetMethod<S> {
716 type Handle = S::Handle;
717 type Method = Set<members::method>;
718 }
719 /// Marker types for field names
720 #[allow(non_camel_case_types)]
721 pub mod members {
722 ///Marker type for the `handle` field
723 pub struct handle(());
724 ///Marker type for the `method` field
725 pub struct method(());
726 }
727}
728
729/// Builder for constructing an instance of this type
730pub struct SuggestionBuilder<'a, S: suggestion_state::State> {
731 _phantom_state: ::core::marker::PhantomData<fn() -> S>,
732 __unsafe_private_named: (
733 ::core::option::Option<jacquard_common::types::string::Handle<'a>>,
734 ::core::option::Option<jacquard_common::CowStr<'a>>,
735 ),
736 _phantom: ::core::marker::PhantomData<&'a ()>,
737}
738
739impl<'a> Suggestion<'a> {
740 /// Create a new builder for this type
741 pub fn new() -> SuggestionBuilder<'a, suggestion_state::Empty> {
742 SuggestionBuilder::new()
743 }
744}
745
746impl<'a> SuggestionBuilder<'a, suggestion_state::Empty> {
747 /// Create a new builder with all fields unset
748 pub fn new() -> Self {
749 SuggestionBuilder {
750 _phantom_state: ::core::marker::PhantomData,
751 __unsafe_private_named: (None, None),
752 _phantom: ::core::marker::PhantomData,
753 }
754 }
755}
756
757impl<'a, S> SuggestionBuilder<'a, S>
758where
759 S: suggestion_state::State,
760 S::Handle: suggestion_state::IsUnset,
761{
762 /// Set the `handle` field (required)
763 pub fn handle(
764 mut self,
765 value: impl Into<jacquard_common::types::string::Handle<'a>>,
766 ) -> SuggestionBuilder<'a, suggestion_state::SetHandle<S>> {
767 self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
768 SuggestionBuilder {
769 _phantom_state: ::core::marker::PhantomData,
770 __unsafe_private_named: self.__unsafe_private_named,
771 _phantom: ::core::marker::PhantomData,
772 }
773 }
774}
775
776impl<'a, S> SuggestionBuilder<'a, S>
777where
778 S: suggestion_state::State,
779 S::Method: suggestion_state::IsUnset,
780{
781 /// Set the `method` field (required)
782 pub fn method(
783 mut self,
784 value: impl Into<jacquard_common::CowStr<'a>>,
785 ) -> SuggestionBuilder<'a, suggestion_state::SetMethod<S>> {
786 self.__unsafe_private_named.1 = ::core::option::Option::Some(value.into());
787 SuggestionBuilder {
788 _phantom_state: ::core::marker::PhantomData,
789 __unsafe_private_named: self.__unsafe_private_named,
790 _phantom: ::core::marker::PhantomData,
791 }
792 }
793}
794
795impl<'a, S> SuggestionBuilder<'a, S>
796where
797 S: suggestion_state::State,
798 S::Handle: suggestion_state::IsSet,
799 S::Method: suggestion_state::IsSet,
800{
801 /// Build the final struct
802 pub fn build(self) -> Suggestion<'a> {
803 Suggestion {
804 handle: self.__unsafe_private_named.0.unwrap(),
805 method: self.__unsafe_private_named.1.unwrap(),
806 extra_data: Default::default(),
807 }
808 }
809 /// Build the final struct with custom extra_data
810 pub fn build_with_data(
811 self,
812 extra_data: std::collections::BTreeMap<
813 jacquard_common::smol_str::SmolStr,
814 jacquard_common::types::value::Data<'a>,
815 >,
816 ) -> Suggestion<'a> {
817 Suggestion {
818 handle: self.__unsafe_private_named.0.unwrap(),
819 method: self.__unsafe_private_named.1.unwrap(),
820 extra_data: Some(extra_data),
821 }
822 }
823}
824
825impl<'a> ::jacquard_lexicon::schema::LexiconSchema for Suggestion<'a> {
826 fn nsid() -> &'static str {
827 "com.atproto.temp.checkHandleAvailability"
828 }
829 fn def_name() -> &'static str {
830 "suggestion"
831 }
832 fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
833 lexicon_doc_com_atproto_temp_checkHandleAvailability()
834 }
835 fn validate(
836 &self,
837 ) -> ::core::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
838 Ok(())
839 }
840}