jacquard_api/com_atproto/server/
describe_server.rs1#[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 #[serde(borrow)]
56 pub available_user_domains: Vec<CowStr<'a>>,
57 #[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 #[serde(skip_serializing_if = "Option::is_none")]
65 pub invite_code_required: Option<bool>,
66 #[serde(skip_serializing_if = "Option::is_none")]
68 #[serde(borrow)]
69 pub links: Option<describe_server::Links<'a>>,
70 #[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#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Copy)]
108pub struct DescribeServer;
109pub 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
124pub 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}