jacquard_api/network_slices/slice/
create_o_auth_client.rs

1// @generated by jacquard-lexicon. DO NOT EDIT.
2//
3// Lexicon: network.slices.slice.createOAuthClient
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 CreateOAuthClient<'a> {
20    /// Human-readable name of the OAuth client
21    #[serde(borrow)]
22    pub client_name: jacquard_common::CowStr<'a>,
23    /// URI of the client application
24    #[serde(skip_serializing_if = "std::option::Option::is_none")]
25    #[serde(borrow)]
26    pub client_uri: Option<jacquard_common::types::string::Uri<'a>>,
27    /// OAuth grant types
28    #[serde(skip_serializing_if = "std::option::Option::is_none")]
29    #[serde(borrow)]
30    pub grant_types: Option<Vec<jacquard_common::CowStr<'a>>>,
31    /// URI of the client logo
32    #[serde(skip_serializing_if = "std::option::Option::is_none")]
33    #[serde(borrow)]
34    pub logo_uri: Option<jacquard_common::types::string::Uri<'a>>,
35    /// URI of the privacy policy
36    #[serde(skip_serializing_if = "std::option::Option::is_none")]
37    #[serde(borrow)]
38    pub policy_uri: Option<jacquard_common::types::string::Uri<'a>>,
39    /// Allowed redirect URIs for OAuth flow (must use HTTP or HTTPS)
40    #[serde(borrow)]
41    pub redirect_uris: Vec<jacquard_common::types::string::Uri<'a>>,
42    /// OAuth response types
43    #[serde(skip_serializing_if = "std::option::Option::is_none")]
44    #[serde(borrow)]
45    pub response_types: Option<Vec<jacquard_common::CowStr<'a>>>,
46    /// OAuth scope
47    #[serde(skip_serializing_if = "std::option::Option::is_none")]
48    #[serde(borrow)]
49    pub scope: Option<jacquard_common::CowStr<'a>>,
50    /// AT-URI of the slice to register the OAuth client for
51    #[serde(borrow)]
52    pub slice_uri: jacquard_common::CowStr<'a>,
53    /// URI of the terms of service
54    #[serde(skip_serializing_if = "std::option::Option::is_none")]
55    #[serde(borrow)]
56    pub tos_uri: Option<jacquard_common::types::string::Uri<'a>>,
57}
58
59pub mod create_o_auth_client_state {
60
61    pub use crate::builder_types::{Set, Unset, IsSet, IsUnset};
62    #[allow(unused)]
63    use ::core::marker::PhantomData;
64    mod sealed {
65        pub trait Sealed {}
66    }
67    /// State trait tracking which required fields have been set
68    pub trait State: sealed::Sealed {
69        type SliceUri;
70        type ClientName;
71        type RedirectUris;
72    }
73    /// Empty state - all required fields are unset
74    pub struct Empty(());
75    impl sealed::Sealed for Empty {}
76    impl State for Empty {
77        type SliceUri = Unset;
78        type ClientName = Unset;
79        type RedirectUris = Unset;
80    }
81    ///State transition - sets the `slice_uri` field to Set
82    pub struct SetSliceUri<S: State = Empty>(PhantomData<fn() -> S>);
83    impl<S: State> sealed::Sealed for SetSliceUri<S> {}
84    impl<S: State> State for SetSliceUri<S> {
85        type SliceUri = Set<members::slice_uri>;
86        type ClientName = S::ClientName;
87        type RedirectUris = S::RedirectUris;
88    }
89    ///State transition - sets the `client_name` field to Set
90    pub struct SetClientName<S: State = Empty>(PhantomData<fn() -> S>);
91    impl<S: State> sealed::Sealed for SetClientName<S> {}
92    impl<S: State> State for SetClientName<S> {
93        type SliceUri = S::SliceUri;
94        type ClientName = Set<members::client_name>;
95        type RedirectUris = S::RedirectUris;
96    }
97    ///State transition - sets the `redirect_uris` field to Set
98    pub struct SetRedirectUris<S: State = Empty>(PhantomData<fn() -> S>);
99    impl<S: State> sealed::Sealed for SetRedirectUris<S> {}
100    impl<S: State> State for SetRedirectUris<S> {
101        type SliceUri = S::SliceUri;
102        type ClientName = S::ClientName;
103        type RedirectUris = Set<members::redirect_uris>;
104    }
105    /// Marker types for field names
106    #[allow(non_camel_case_types)]
107    pub mod members {
108        ///Marker type for the `slice_uri` field
109        pub struct slice_uri(());
110        ///Marker type for the `client_name` field
111        pub struct client_name(());
112        ///Marker type for the `redirect_uris` field
113        pub struct redirect_uris(());
114    }
115}
116
117/// Builder for constructing an instance of this type
118pub struct CreateOAuthClientBuilder<'a, S: create_o_auth_client_state::State> {
119    _phantom_state: ::core::marker::PhantomData<fn() -> S>,
120    __unsafe_private_named: (
121        ::core::option::Option<jacquard_common::CowStr<'a>>,
122        ::core::option::Option<jacquard_common::types::string::Uri<'a>>,
123        ::core::option::Option<Vec<jacquard_common::CowStr<'a>>>,
124        ::core::option::Option<jacquard_common::types::string::Uri<'a>>,
125        ::core::option::Option<jacquard_common::types::string::Uri<'a>>,
126        ::core::option::Option<Vec<jacquard_common::types::string::Uri<'a>>>,
127        ::core::option::Option<Vec<jacquard_common::CowStr<'a>>>,
128        ::core::option::Option<jacquard_common::CowStr<'a>>,
129        ::core::option::Option<jacquard_common::CowStr<'a>>,
130        ::core::option::Option<jacquard_common::types::string::Uri<'a>>,
131    ),
132    _phantom: ::core::marker::PhantomData<&'a ()>,
133}
134
135impl<'a> CreateOAuthClient<'a> {
136    /// Create a new builder for this type
137    pub fn new() -> CreateOAuthClientBuilder<'a, create_o_auth_client_state::Empty> {
138        CreateOAuthClientBuilder::new()
139    }
140}
141
142impl<'a> CreateOAuthClientBuilder<'a, create_o_auth_client_state::Empty> {
143    /// Create a new builder with all fields unset
144    pub fn new() -> Self {
145        CreateOAuthClientBuilder {
146            _phantom_state: ::core::marker::PhantomData,
147            __unsafe_private_named: (
148                None,
149                None,
150                None,
151                None,
152                None,
153                None,
154                None,
155                None,
156                None,
157                None,
158            ),
159            _phantom: ::core::marker::PhantomData,
160        }
161    }
162}
163
164impl<'a, S> CreateOAuthClientBuilder<'a, S>
165where
166    S: create_o_auth_client_state::State,
167    S::ClientName: create_o_auth_client_state::IsUnset,
168{
169    /// Set the `clientName` field (required)
170    pub fn client_name(
171        mut self,
172        value: impl Into<jacquard_common::CowStr<'a>>,
173    ) -> CreateOAuthClientBuilder<'a, create_o_auth_client_state::SetClientName<S>> {
174        self.__unsafe_private_named.0 = ::core::option::Option::Some(value.into());
175        CreateOAuthClientBuilder {
176            _phantom_state: ::core::marker::PhantomData,
177            __unsafe_private_named: self.__unsafe_private_named,
178            _phantom: ::core::marker::PhantomData,
179        }
180    }
181}
182
183impl<'a, S: create_o_auth_client_state::State> CreateOAuthClientBuilder<'a, S> {
184    /// Set the `clientUri` field (optional)
185    pub fn client_uri(
186        mut self,
187        value: impl Into<Option<jacquard_common::types::string::Uri<'a>>>,
188    ) -> Self {
189        self.__unsafe_private_named.1 = value.into();
190        self
191    }
192    /// Set the `clientUri` field to an Option value (optional)
193    pub fn maybe_client_uri(
194        mut self,
195        value: Option<jacquard_common::types::string::Uri<'a>>,
196    ) -> Self {
197        self.__unsafe_private_named.1 = value;
198        self
199    }
200}
201
202impl<'a, S: create_o_auth_client_state::State> CreateOAuthClientBuilder<'a, S> {
203    /// Set the `grantTypes` field (optional)
204    pub fn grant_types(
205        mut self,
206        value: impl Into<Option<Vec<jacquard_common::CowStr<'a>>>>,
207    ) -> Self {
208        self.__unsafe_private_named.2 = value.into();
209        self
210    }
211    /// Set the `grantTypes` field to an Option value (optional)
212    pub fn maybe_grant_types(
213        mut self,
214        value: Option<Vec<jacquard_common::CowStr<'a>>>,
215    ) -> Self {
216        self.__unsafe_private_named.2 = value;
217        self
218    }
219}
220
221impl<'a, S: create_o_auth_client_state::State> CreateOAuthClientBuilder<'a, S> {
222    /// Set the `logoUri` field (optional)
223    pub fn logo_uri(
224        mut self,
225        value: impl Into<Option<jacquard_common::types::string::Uri<'a>>>,
226    ) -> Self {
227        self.__unsafe_private_named.3 = value.into();
228        self
229    }
230    /// Set the `logoUri` field to an Option value (optional)
231    pub fn maybe_logo_uri(
232        mut self,
233        value: Option<jacquard_common::types::string::Uri<'a>>,
234    ) -> Self {
235        self.__unsafe_private_named.3 = value;
236        self
237    }
238}
239
240impl<'a, S: create_o_auth_client_state::State> CreateOAuthClientBuilder<'a, S> {
241    /// Set the `policyUri` field (optional)
242    pub fn policy_uri(
243        mut self,
244        value: impl Into<Option<jacquard_common::types::string::Uri<'a>>>,
245    ) -> Self {
246        self.__unsafe_private_named.4 = value.into();
247        self
248    }
249    /// Set the `policyUri` field to an Option value (optional)
250    pub fn maybe_policy_uri(
251        mut self,
252        value: Option<jacquard_common::types::string::Uri<'a>>,
253    ) -> Self {
254        self.__unsafe_private_named.4 = value;
255        self
256    }
257}
258
259impl<'a, S> CreateOAuthClientBuilder<'a, S>
260where
261    S: create_o_auth_client_state::State,
262    S::RedirectUris: create_o_auth_client_state::IsUnset,
263{
264    /// Set the `redirectUris` field (required)
265    pub fn redirect_uris(
266        mut self,
267        value: impl Into<Vec<jacquard_common::types::string::Uri<'a>>>,
268    ) -> CreateOAuthClientBuilder<'a, create_o_auth_client_state::SetRedirectUris<S>> {
269        self.__unsafe_private_named.5 = ::core::option::Option::Some(value.into());
270        CreateOAuthClientBuilder {
271            _phantom_state: ::core::marker::PhantomData,
272            __unsafe_private_named: self.__unsafe_private_named,
273            _phantom: ::core::marker::PhantomData,
274        }
275    }
276}
277
278impl<'a, S: create_o_auth_client_state::State> CreateOAuthClientBuilder<'a, S> {
279    /// Set the `responseTypes` field (optional)
280    pub fn response_types(
281        mut self,
282        value: impl Into<Option<Vec<jacquard_common::CowStr<'a>>>>,
283    ) -> Self {
284        self.__unsafe_private_named.6 = value.into();
285        self
286    }
287    /// Set the `responseTypes` field to an Option value (optional)
288    pub fn maybe_response_types(
289        mut self,
290        value: Option<Vec<jacquard_common::CowStr<'a>>>,
291    ) -> Self {
292        self.__unsafe_private_named.6 = value;
293        self
294    }
295}
296
297impl<'a, S: create_o_auth_client_state::State> CreateOAuthClientBuilder<'a, S> {
298    /// Set the `scope` field (optional)
299    pub fn scope(
300        mut self,
301        value: impl Into<Option<jacquard_common::CowStr<'a>>>,
302    ) -> Self {
303        self.__unsafe_private_named.7 = value.into();
304        self
305    }
306    /// Set the `scope` field to an Option value (optional)
307    pub fn maybe_scope(mut self, value: Option<jacquard_common::CowStr<'a>>) -> Self {
308        self.__unsafe_private_named.7 = value;
309        self
310    }
311}
312
313impl<'a, S> CreateOAuthClientBuilder<'a, S>
314where
315    S: create_o_auth_client_state::State,
316    S::SliceUri: create_o_auth_client_state::IsUnset,
317{
318    /// Set the `sliceUri` field (required)
319    pub fn slice_uri(
320        mut self,
321        value: impl Into<jacquard_common::CowStr<'a>>,
322    ) -> CreateOAuthClientBuilder<'a, create_o_auth_client_state::SetSliceUri<S>> {
323        self.__unsafe_private_named.8 = ::core::option::Option::Some(value.into());
324        CreateOAuthClientBuilder {
325            _phantom_state: ::core::marker::PhantomData,
326            __unsafe_private_named: self.__unsafe_private_named,
327            _phantom: ::core::marker::PhantomData,
328        }
329    }
330}
331
332impl<'a, S: create_o_auth_client_state::State> CreateOAuthClientBuilder<'a, S> {
333    /// Set the `tosUri` field (optional)
334    pub fn tos_uri(
335        mut self,
336        value: impl Into<Option<jacquard_common::types::string::Uri<'a>>>,
337    ) -> Self {
338        self.__unsafe_private_named.9 = value.into();
339        self
340    }
341    /// Set the `tosUri` field to an Option value (optional)
342    pub fn maybe_tos_uri(
343        mut self,
344        value: Option<jacquard_common::types::string::Uri<'a>>,
345    ) -> Self {
346        self.__unsafe_private_named.9 = value;
347        self
348    }
349}
350
351impl<'a, S> CreateOAuthClientBuilder<'a, S>
352where
353    S: create_o_auth_client_state::State,
354    S::SliceUri: create_o_auth_client_state::IsSet,
355    S::ClientName: create_o_auth_client_state::IsSet,
356    S::RedirectUris: create_o_auth_client_state::IsSet,
357{
358    /// Build the final struct
359    pub fn build(self) -> CreateOAuthClient<'a> {
360        CreateOAuthClient {
361            client_name: self.__unsafe_private_named.0.unwrap(),
362            client_uri: self.__unsafe_private_named.1,
363            grant_types: self.__unsafe_private_named.2,
364            logo_uri: self.__unsafe_private_named.3,
365            policy_uri: self.__unsafe_private_named.4,
366            redirect_uris: self.__unsafe_private_named.5.unwrap(),
367            response_types: self.__unsafe_private_named.6,
368            scope: self.__unsafe_private_named.7,
369            slice_uri: self.__unsafe_private_named.8.unwrap(),
370            tos_uri: self.__unsafe_private_named.9,
371            extra_data: Default::default(),
372        }
373    }
374    /// Build the final struct with custom extra_data
375    pub fn build_with_data(
376        self,
377        extra_data: std::collections::BTreeMap<
378            jacquard_common::smol_str::SmolStr,
379            jacquard_common::types::value::Data<'a>,
380        >,
381    ) -> CreateOAuthClient<'a> {
382        CreateOAuthClient {
383            client_name: self.__unsafe_private_named.0.unwrap(),
384            client_uri: self.__unsafe_private_named.1,
385            grant_types: self.__unsafe_private_named.2,
386            logo_uri: self.__unsafe_private_named.3,
387            policy_uri: self.__unsafe_private_named.4,
388            redirect_uris: self.__unsafe_private_named.5.unwrap(),
389            response_types: self.__unsafe_private_named.6,
390            scope: self.__unsafe_private_named.7,
391            slice_uri: self.__unsafe_private_named.8.unwrap(),
392            tos_uri: self.__unsafe_private_named.9,
393            extra_data: Some(extra_data),
394        }
395    }
396}
397
398#[jacquard_derive::lexicon]
399#[derive(
400    serde::Serialize,
401    serde::Deserialize,
402    Debug,
403    Clone,
404    PartialEq,
405    Eq,
406    jacquard_derive::IntoStatic
407)]
408#[serde(rename_all = "camelCase")]
409pub struct CreateOAuthClientOutput<'a> {
410    #[serde(flatten)]
411    #[serde(borrow)]
412    pub value: crate::network_slices::slice::get_o_auth_clients::OauthClientDetails<'a>,
413}
414
415/// Response type for
416///network.slices.slice.createOAuthClient
417pub struct CreateOAuthClientResponse;
418impl jacquard_common::xrpc::XrpcResp for CreateOAuthClientResponse {
419    const NSID: &'static str = "network.slices.slice.createOAuthClient";
420    const ENCODING: &'static str = "application/json";
421    type Output<'de> = CreateOAuthClientOutput<'de>;
422    type Err<'de> = jacquard_common::xrpc::GenericError<'de>;
423}
424
425impl<'a> jacquard_common::xrpc::XrpcRequest for CreateOAuthClient<'a> {
426    const NSID: &'static str = "network.slices.slice.createOAuthClient";
427    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
428        "application/json",
429    );
430    type Response = CreateOAuthClientResponse;
431}
432
433/// Endpoint type for
434///network.slices.slice.createOAuthClient
435pub struct CreateOAuthClientRequest;
436impl jacquard_common::xrpc::XrpcEndpoint for CreateOAuthClientRequest {
437    const PATH: &'static str = "/xrpc/network.slices.slice.createOAuthClient";
438    const METHOD: jacquard_common::xrpc::XrpcMethod = jacquard_common::xrpc::XrpcMethod::Procedure(
439        "application/json",
440    );
441    type Request<'de> = CreateOAuthClient<'de>;
442    type Response = CreateOAuthClientResponse;
443}