Skip to main content

jacquard_api/com_atproto/server/
describe_server.rs

1// @generated by jacquard-lexicon. DO NOT EDIT.
2//
3// Lexicon: com.atproto.server.describeServer
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::string::{Did, UriValue};
18use jacquard_derive::{IntoStatic, lexicon};
19use jacquard_lexicon::lexicon::LexiconDoc;
20use jacquard_lexicon::schema::LexiconSchema;
21
22#[allow(unused_imports)]
23use jacquard_lexicon::validation::{ConstraintError, ValidationPath};
24use serde::{Serialize, Deserialize};
25use crate::com_atproto::server::describe_server;
26
27#[lexicon]
28#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
29#[serde(rename_all = "camelCase")]
30pub struct Contact<'a> {
31    #[serde(skip_serializing_if = "Option::is_none")]
32    #[serde(borrow)]
33    pub email: Option<CowStr<'a>>,
34}
35
36
37#[lexicon]
38#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Default)]
39#[serde(rename_all = "camelCase")]
40pub struct Links<'a> {
41    #[serde(skip_serializing_if = "Option::is_none")]
42    #[serde(borrow)]
43    pub privacy_policy: Option<UriValue<'a>>,
44    #[serde(skip_serializing_if = "Option::is_none")]
45    #[serde(borrow)]
46    pub terms_of_service: Option<UriValue<'a>>,
47}
48
49
50#[lexicon]
51#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic)]
52#[serde(rename_all = "camelCase")]
53pub struct DescribeServerOutput<'a> {
54    ///List of domain suffixes that can be used in account handles.
55    #[serde(borrow)]
56    pub available_user_domains: Vec<CowStr<'a>>,
57    ///Contact information
58    #[serde(skip_serializing_if = "Option::is_none")]
59    #[serde(borrow)]
60    pub contact: Option<describe_server::Contact<'a>>,
61    #[serde(borrow)]
62    pub did: Did<'a>,
63    ///If true, an invite code must be supplied to create an account on this instance.
64    #[serde(skip_serializing_if = "Option::is_none")]
65    pub invite_code_required: Option<bool>,
66    ///URLs of service policy documents.
67    #[serde(skip_serializing_if = "Option::is_none")]
68    #[serde(borrow)]
69    pub links: Option<describe_server::Links<'a>>,
70    ///If true, a phone verification token must be supplied to create an account on this instance.
71    #[serde(skip_serializing_if = "Option::is_none")]
72    pub phone_verification_required: Option<bool>,
73}
74
75impl<'a> LexiconSchema for Contact<'a> {
76    fn nsid() -> &'static str {
77        "com.atproto.server.describeServer"
78    }
79    fn def_name() -> &'static str {
80        "contact"
81    }
82    fn lexicon_doc() -> LexiconDoc<'static> {
83        lexicon_doc_com_atproto_server_describeServer()
84    }
85    fn validate(&self) -> Result<(), ConstraintError> {
86        Ok(())
87    }
88}
89
90impl<'a> LexiconSchema for Links<'a> {
91    fn nsid() -> &'static str {
92        "com.atproto.server.describeServer"
93    }
94    fn def_name() -> &'static str {
95        "links"
96    }
97    fn lexicon_doc() -> LexiconDoc<'static> {
98        lexicon_doc_com_atproto_server_describeServer()
99    }
100    fn validate(&self) -> Result<(), ConstraintError> {
101        Ok(())
102    }
103}
104
105/// XRPC request marker type.
106
107#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Copy)]
108pub struct DescribeServer;
109/// Response type for com.atproto.server.describeServer
110pub struct DescribeServerResponse;
111impl jacquard_common::xrpc::XrpcResp for DescribeServerResponse {
112    const NSID: &'static str = "com.atproto.server.describeServer";
113    const ENCODING: &'static str = "application/json";
114    type Output<'de> = DescribeServerOutput<'de>;
115    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
116}
117
118impl jacquard_common::xrpc::XrpcRequest for DescribeServer {
119    const NSID: &'static str = "com.atproto.server.describeServer";
120    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
121    type Response = DescribeServerResponse;
122}
123
124/// Endpoint type for com.atproto.server.describeServer
125pub struct DescribeServerRequest;
126impl jacquard_common::xrpc::XrpcEndpoint for DescribeServerRequest {
127    const PATH: &'static str = "/xrpc/com.atproto.server.describeServer";
128    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
129    type Request<'de> = DescribeServer;
130    type Response = DescribeServerResponse;
131}
132
133fn lexicon_doc_com_atproto_server_describeServer() -> LexiconDoc<'static> {
134    #[allow(unused_imports)]
135    use jacquard_common::{CowStr, deps::smol_str::SmolStr, types::blob::MimeType};
136    use jacquard_lexicon::lexicon::*;
137    use alloc::collections::BTreeMap;
138    LexiconDoc {
139        lexicon: Lexicon::Lexicon1,
140        id: CowStr::new_static("com.atproto.server.describeServer"),
141        defs: {
142            let mut map = BTreeMap::new();
143            map.insert(
144                SmolStr::new_static("contact"),
145                LexUserType::Object(LexObject {
146                    properties: {
147                        #[allow(unused_mut)]
148                        let mut map = BTreeMap::new();
149                        map.insert(
150                            SmolStr::new_static("email"),
151                            LexObjectProperty::String(LexString { ..Default::default() }),
152                        );
153                        map
154                    },
155                    ..Default::default()
156                }),
157            );
158            map.insert(
159                SmolStr::new_static("links"),
160                LexUserType::Object(LexObject {
161                    properties: {
162                        #[allow(unused_mut)]
163                        let mut map = BTreeMap::new();
164                        map.insert(
165                            SmolStr::new_static("privacyPolicy"),
166                            LexObjectProperty::String(LexString {
167                                format: Some(LexStringFormat::Uri),
168                                ..Default::default()
169                            }),
170                        );
171                        map.insert(
172                            SmolStr::new_static("termsOfService"),
173                            LexObjectProperty::String(LexString {
174                                format: Some(LexStringFormat::Uri),
175                                ..Default::default()
176                            }),
177                        );
178                        map
179                    },
180                    ..Default::default()
181                }),
182            );
183            map.insert(
184                SmolStr::new_static("main"),
185                LexUserType::XrpcQuery(LexXrpcQuery {
186                    parameters: None,
187                    ..Default::default()
188                }),
189            );
190            map
191        },
192        ..Default::default()
193    }
194}