jacquard_api/network_slices/slice/
create_o_auth_client.rs1#[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 #[serde(borrow)]
22 pub client_name: jacquard_common::CowStr<'a>,
23 #[serde(skip_serializing_if = "std::option::Option::is_none")]
25 #[serde(borrow)]
26 pub client_uri: Option<jacquard_common::types::string::Uri<'a>>,
27 #[serde(skip_serializing_if = "std::option::Option::is_none")]
29 #[serde(borrow)]
30 pub grant_types: Option<Vec<jacquard_common::CowStr<'a>>>,
31 #[serde(skip_serializing_if = "std::option::Option::is_none")]
33 #[serde(borrow)]
34 pub logo_uri: Option<jacquard_common::types::string::Uri<'a>>,
35 #[serde(skip_serializing_if = "std::option::Option::is_none")]
37 #[serde(borrow)]
38 pub policy_uri: Option<jacquard_common::types::string::Uri<'a>>,
39 #[serde(borrow)]
41 pub redirect_uris: Vec<jacquard_common::types::string::Uri<'a>>,
42 #[serde(skip_serializing_if = "std::option::Option::is_none")]
44 #[serde(borrow)]
45 pub response_types: Option<Vec<jacquard_common::CowStr<'a>>>,
46 #[serde(skip_serializing_if = "std::option::Option::is_none")]
48 #[serde(borrow)]
49 pub scope: Option<jacquard_common::CowStr<'a>>,
50 #[serde(borrow)]
52 pub slice_uri: jacquard_common::CowStr<'a>,
53 #[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 pub trait State: sealed::Sealed {
69 type SliceUri;
70 type ClientName;
71 type RedirectUris;
72 }
73 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 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 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 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 #[allow(non_camel_case_types)]
107 pub mod members {
108 pub struct slice_uri(());
110 pub struct client_name(());
112 pub struct redirect_uris(());
114 }
115}
116
117pub 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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
415pub 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
433pub 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}