jacquard_api/tools_ozone/server/
get_config.rs

1// @generated by jacquard-lexicon. DO NOT EDIT.
2//
3// Lexicon: tools.ozone.server.getConfig
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    Default
18)]
19#[serde(rename_all = "camelCase")]
20pub struct GetConfigOutput<'a> {
21    #[serde(skip_serializing_if = "std::option::Option::is_none")]
22    #[serde(borrow)]
23    pub appview: std::option::Option<
24        crate::tools_ozone::server::get_config::ServiceConfig<'a>,
25    >,
26    #[serde(skip_serializing_if = "std::option::Option::is_none")]
27    #[serde(borrow)]
28    pub blob_divert: std::option::Option<
29        crate::tools_ozone::server::get_config::ServiceConfig<'a>,
30    >,
31    #[serde(skip_serializing_if = "std::option::Option::is_none")]
32    #[serde(borrow)]
33    pub chat: std::option::Option<
34        crate::tools_ozone::server::get_config::ServiceConfig<'a>,
35    >,
36    #[serde(skip_serializing_if = "std::option::Option::is_none")]
37    #[serde(borrow)]
38    pub pds: std::option::Option<
39        crate::tools_ozone::server::get_config::ServiceConfig<'a>,
40    >,
41    /// The did of the verifier used for verification.
42    #[serde(skip_serializing_if = "std::option::Option::is_none")]
43    #[serde(borrow)]
44    pub verifier_did: std::option::Option<jacquard_common::types::string::Did<'a>>,
45    #[serde(skip_serializing_if = "std::option::Option::is_none")]
46    #[serde(borrow)]
47    pub viewer: std::option::Option<
48        crate::tools_ozone::server::get_config::ViewerConfig<'a>,
49    >,
50}
51
52/// XRPC request marker type
53#[derive(
54    Debug,
55    Clone,
56    Copy,
57    PartialEq,
58    Eq,
59    serde::Serialize,
60    serde::Deserialize,
61    jacquard_derive::IntoStatic
62)]
63pub struct GetConfig;
64/// Response type for
65///tools.ozone.server.getConfig
66pub struct GetConfigResponse;
67impl jacquard_common::xrpc::XrpcResp for GetConfigResponse {
68    const NSID: &'static str = "tools.ozone.server.getConfig";
69    const ENCODING: &'static str = "application/json";
70    type Output<'de> = GetConfigOutput<'de>;
71    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
72}
73
74impl jacquard_common::xrpc::XrpcRequest for GetConfig {
75    const NSID: &'static str = "tools.ozone.server.getConfig";
76    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
77    type Response = GetConfigResponse;
78}
79
80/// Endpoint type for
81///tools.ozone.server.getConfig
82pub struct GetConfigRequest;
83impl jacquard_common::xrpc::XrpcEndpoint for GetConfigRequest {
84    const PATH: &'static str = "/xrpc/tools.ozone.server.getConfig";
85    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Query;
86    type Request<'de> = GetConfig;
87    type Response = GetConfigResponse;
88}
89
90#[jacquard_derive::lexicon]
91#[derive(
92    serde::Serialize,
93    serde::Deserialize,
94    Debug,
95    Clone,
96    PartialEq,
97    Eq,
98    jacquard_derive::IntoStatic,
99    Default
100)]
101#[serde(rename_all = "camelCase")]
102pub struct ServiceConfig<'a> {
103    #[serde(skip_serializing_if = "std::option::Option::is_none")]
104    #[serde(borrow)]
105    pub url: std::option::Option<jacquard_common::types::string::Uri<'a>>,
106}
107
108fn lexicon_doc_tools_ozone_server_getConfig() -> ::jacquard_lexicon::lexicon::LexiconDoc<
109    'static,
110> {
111    ::jacquard_lexicon::lexicon::LexiconDoc {
112        lexicon: ::jacquard_lexicon::lexicon::Lexicon::Lexicon1,
113        id: ::jacquard_common::CowStr::new_static("tools.ozone.server.getConfig"),
114        revision: None,
115        description: None,
116        defs: {
117            let mut map = ::std::collections::BTreeMap::new();
118            map.insert(
119                ::jacquard_common::smol_str::SmolStr::new_static("main"),
120                ::jacquard_lexicon::lexicon::LexUserType::XrpcQuery(::jacquard_lexicon::lexicon::LexXrpcQuery {
121                    description: None,
122                    parameters: None,
123                    output: None,
124                    errors: None,
125                }),
126            );
127            map.insert(
128                ::jacquard_common::smol_str::SmolStr::new_static("serviceConfig"),
129                ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
130                    description: None,
131                    required: None,
132                    nullable: None,
133                    properties: {
134                        #[allow(unused_mut)]
135                        let mut map = ::std::collections::BTreeMap::new();
136                        map.insert(
137                            ::jacquard_common::smol_str::SmolStr::new_static("url"),
138                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
139                                description: None,
140                                format: Some(
141                                    ::jacquard_lexicon::lexicon::LexStringFormat::Uri,
142                                ),
143                                default: None,
144                                min_length: None,
145                                max_length: None,
146                                min_graphemes: None,
147                                max_graphemes: None,
148                                r#enum: None,
149                                r#const: None,
150                                known_values: None,
151                            }),
152                        );
153                        map
154                    },
155                }),
156            );
157            map.insert(
158                ::jacquard_common::smol_str::SmolStr::new_static("viewerConfig"),
159                ::jacquard_lexicon::lexicon::LexUserType::Object(::jacquard_lexicon::lexicon::LexObject {
160                    description: None,
161                    required: None,
162                    nullable: None,
163                    properties: {
164                        #[allow(unused_mut)]
165                        let mut map = ::std::collections::BTreeMap::new();
166                        map.insert(
167                            ::jacquard_common::smol_str::SmolStr::new_static("role"),
168                            ::jacquard_lexicon::lexicon::LexObjectProperty::String(::jacquard_lexicon::lexicon::LexString {
169                                description: None,
170                                format: None,
171                                default: None,
172                                min_length: None,
173                                max_length: None,
174                                min_graphemes: None,
175                                max_graphemes: None,
176                                r#enum: None,
177                                r#const: None,
178                                known_values: None,
179                            }),
180                        );
181                        map
182                    },
183                }),
184            );
185            map
186        },
187    }
188}
189
190impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ServiceConfig<'a> {
191    fn nsid() -> &'static str {
192        "tools.ozone.server.getConfig"
193    }
194    fn def_name() -> &'static str {
195        "serviceConfig"
196    }
197    fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
198        lexicon_doc_tools_ozone_server_getConfig()
199    }
200    fn validate(
201        &self,
202    ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
203        Ok(())
204    }
205}
206
207#[jacquard_derive::lexicon]
208#[derive(
209    serde::Serialize,
210    serde::Deserialize,
211    Debug,
212    Clone,
213    PartialEq,
214    Eq,
215    jacquard_derive::IntoStatic,
216    Default
217)]
218#[serde(rename_all = "camelCase")]
219pub struct ViewerConfig<'a> {
220    #[serde(skip_serializing_if = "std::option::Option::is_none")]
221    #[serde(borrow)]
222    pub role: std::option::Option<jacquard_common::CowStr<'a>>,
223}
224
225impl<'a> ::jacquard_lexicon::schema::LexiconSchema for ViewerConfig<'a> {
226    fn nsid() -> &'static str {
227        "tools.ozone.server.getConfig"
228    }
229    fn def_name() -> &'static str {
230        "viewerConfig"
231    }
232    fn lexicon_doc() -> ::jacquard_lexicon::lexicon::LexiconDoc<'static> {
233        lexicon_doc_tools_ozone_server_getConfig()
234    }
235    fn validate(
236        &self,
237    ) -> ::std::result::Result<(), ::jacquard_lexicon::validation::ConstraintError> {
238        Ok(())
239    }
240}