gitbundle_sdk/apis/
user_api.rs

1/*
2 * GitBundle API
3 *
4 * GitBundle API documentation.
5 *
6 * The version of the OpenAPI document: 3.4.1
7 *
8 * Generated by: https://openapi-generator.tech
9 */
10
11use reqwest;
12use serde::{de::Error as _, Deserialize, Serialize};
13
14use super::{configuration, ContentType, Error};
15use crate::{apis::ResponseContent, models};
16
17/// struct for typed errors of method [`delete_public_key`]
18#[derive(Debug, Clone, Serialize, Deserialize)]
19#[serde(untagged)]
20pub enum DeletePublicKeyError {
21    Status400(models::JsonErrorResponseNull),
22    Status401(models::JsonErrorResponseNull),
23    Status403(models::JsonErrorResponseNull),
24    Status404(models::JsonErrorResponseNull),
25    Status409(models::JsonErrorResponseNull),
26    Status429(models::JsonErrorResponseNull),
27    Status500(models::JsonErrorResponseNull),
28    UnknownValue(serde_json::Value),
29}
30
31/// struct for typed errors of method [`delete_session`]
32#[derive(Debug, Clone, Serialize, Deserialize)]
33#[serde(untagged)]
34pub enum DeleteSessionError {
35    Status400(models::JsonErrorResponseNull),
36    Status401(models::JsonErrorResponseNull),
37    Status403(models::JsonErrorResponseNull),
38    Status404(models::JsonErrorResponseNull),
39    Status409(models::JsonErrorResponseNull),
40    Status429(models::JsonErrorResponseNull),
41    Status500(models::JsonErrorResponseNull),
42    UnknownValue(serde_json::Value),
43}
44
45/// struct for typed errors of method [`delete_token`]
46#[derive(Debug, Clone, Serialize, Deserialize)]
47#[serde(untagged)]
48pub enum DeleteTokenError {
49    Status400(models::JsonErrorResponseNull),
50    Status401(models::JsonErrorResponseNull),
51    Status403(models::JsonErrorResponseNull),
52    Status404(models::JsonErrorResponseNull),
53    Status409(models::JsonErrorResponseNull),
54    Status429(models::JsonErrorResponseNull),
55    Status500(models::JsonErrorResponseNull),
56    UnknownValue(serde_json::Value),
57}
58
59/// struct for typed errors of method [`delete_two_factor`]
60#[derive(Debug, Clone, Serialize, Deserialize)]
61#[serde(untagged)]
62pub enum DeleteTwoFactorError {
63    Status400(models::JsonErrorResponseNull),
64    Status401(models::JsonErrorResponseNull),
65    Status403(models::JsonErrorResponseNull),
66    Status404(models::JsonErrorResponseNull),
67    Status409(models::JsonErrorResponseNull),
68    Status429(models::JsonErrorResponseNull),
69    Status500(models::JsonErrorResponseNull),
70    UnknownValue(serde_json::Value),
71}
72
73/// struct for typed errors of method [`get_feeds`]
74#[derive(Debug, Clone, Serialize, Deserialize)]
75#[serde(untagged)]
76pub enum GetFeedsError {
77    Status400(models::JsonErrorResponseNull),
78    Status401(models::JsonErrorResponseNull),
79    Status403(models::JsonErrorResponseNull),
80    Status404(models::JsonErrorResponseNull),
81    Status409(models::JsonErrorResponseNull),
82    Status429(models::JsonErrorResponseNull),
83    Status500(models::JsonErrorResponseNull),
84    UnknownValue(serde_json::Value),
85}
86
87/// struct for typed errors of method [`get_has_perm`]
88#[derive(Debug, Clone, Serialize, Deserialize)]
89#[serde(untagged)]
90pub enum GetHasPermError {
91    Status400(models::JsonErrorResponseNull),
92    Status401(models::JsonErrorResponseNull),
93    Status403(models::JsonErrorResponseNull),
94    Status404(models::JsonErrorResponseNull),
95    Status409(models::JsonErrorResponseNull),
96    Status429(models::JsonErrorResponseNull),
97    Status500(models::JsonErrorResponseNull),
98    UnknownValue(serde_json::Value),
99}
100
101/// struct for typed errors of method [`get_heatmap`]
102#[derive(Debug, Clone, Serialize, Deserialize)]
103#[serde(untagged)]
104pub enum GetHeatmapError {
105    Status400(models::JsonErrorResponseNull),
106    Status401(models::JsonErrorResponseNull),
107    Status403(models::JsonErrorResponseNull),
108    Status404(models::JsonErrorResponseNull),
109    Status409(models::JsonErrorResponseNull),
110    Status429(models::JsonErrorResponseNull),
111    Status500(models::JsonErrorResponseNull),
112    UnknownValue(serde_json::Value),
113}
114
115/// struct for typed errors of method [`get_memberships`]
116#[derive(Debug, Clone, Serialize, Deserialize)]
117#[serde(untagged)]
118pub enum GetMembershipsError {
119    Status400(models::JsonErrorResponseNull),
120    Status401(models::JsonErrorResponseNull),
121    Status403(models::JsonErrorResponseNull),
122    Status404(models::JsonErrorResponseNull),
123    Status409(models::JsonErrorResponseNull),
124    Status429(models::JsonErrorResponseNull),
125    Status500(models::JsonErrorResponseNull),
126    UnknownValue(serde_json::Value),
127}
128
129/// struct for typed errors of method [`get_public_keys`]
130#[derive(Debug, Clone, Serialize, Deserialize)]
131#[serde(untagged)]
132pub enum GetPublicKeysError {
133    Status400(models::JsonErrorResponseNull),
134    Status401(models::JsonErrorResponseNull),
135    Status403(models::JsonErrorResponseNull),
136    Status404(models::JsonErrorResponseNull),
137    Status409(models::JsonErrorResponseNull),
138    Status429(models::JsonErrorResponseNull),
139    Status500(models::JsonErrorResponseNull),
140    UnknownValue(serde_json::Value),
141}
142
143/// struct for typed errors of method [`get_sessions`]
144#[derive(Debug, Clone, Serialize, Deserialize)]
145#[serde(untagged)]
146pub enum GetSessionsError {
147    Status400(models::JsonErrorResponseNull),
148    Status401(models::JsonErrorResponseNull),
149    Status403(models::JsonErrorResponseNull),
150    Status404(models::JsonErrorResponseNull),
151    Status409(models::JsonErrorResponseNull),
152    Status429(models::JsonErrorResponseNull),
153    Status500(models::JsonErrorResponseNull),
154    UnknownValue(serde_json::Value),
155}
156
157/// struct for typed errors of method [`get_tokens`]
158#[derive(Debug, Clone, Serialize, Deserialize)]
159#[serde(untagged)]
160pub enum GetTokensError {
161    Status400(models::JsonErrorResponseNull),
162    Status401(models::JsonErrorResponseNull),
163    Status403(models::JsonErrorResponseNull),
164    Status404(models::JsonErrorResponseNull),
165    Status409(models::JsonErrorResponseNull),
166    Status429(models::JsonErrorResponseNull),
167    Status500(models::JsonErrorResponseNull),
168    UnknownValue(serde_json::Value),
169}
170
171/// struct for typed errors of method [`get_two_factor`]
172#[derive(Debug, Clone, Serialize, Deserialize)]
173#[serde(untagged)]
174pub enum GetTwoFactorError {
175    Status400(models::JsonErrorResponseNull),
176    Status401(models::JsonErrorResponseNull),
177    Status403(models::JsonErrorResponseNull),
178    Status404(models::JsonErrorResponseNull),
179    Status409(models::JsonErrorResponseNull),
180    Status429(models::JsonErrorResponseNull),
181    Status500(models::JsonErrorResponseNull),
182    UnknownValue(serde_json::Value),
183}
184
185/// struct for typed errors of method [`get_user_groups`]
186#[derive(Debug, Clone, Serialize, Deserialize)]
187#[serde(untagged)]
188pub enum GetUserGroupsError {
189    Status400(models::JsonErrorResponseNull),
190    Status401(models::JsonErrorResponseNull),
191    Status403(models::JsonErrorResponseNull),
192    Status404(models::JsonErrorResponseNull),
193    Status409(models::JsonErrorResponseNull),
194    Status429(models::JsonErrorResponseNull),
195    Status500(models::JsonErrorResponseNull),
196    UnknownValue(serde_json::Value),
197}
198
199/// struct for typed errors of method [`get_user_repos`]
200#[derive(Debug, Clone, Serialize, Deserialize)]
201#[serde(untagged)]
202pub enum GetUserReposError {
203    Status400(models::JsonErrorResponseNull),
204    Status401(models::JsonErrorResponseNull),
205    Status403(models::JsonErrorResponseNull),
206    Status404(models::JsonErrorResponseNull),
207    Status409(models::JsonErrorResponseNull),
208    Status429(models::JsonErrorResponseNull),
209    Status500(models::JsonErrorResponseNull),
210    UnknownValue(serde_json::Value),
211}
212
213/// struct for typed errors of method [`get_user_stars`]
214#[derive(Debug, Clone, Serialize, Deserialize)]
215#[serde(untagged)]
216pub enum GetUserStarsError {
217    Status400(models::JsonErrorResponseNull),
218    Status401(models::JsonErrorResponseNull),
219    Status403(models::JsonErrorResponseNull),
220    Status404(models::JsonErrorResponseNull),
221    Status409(models::JsonErrorResponseNull),
222    Status429(models::JsonErrorResponseNull),
223    Status500(models::JsonErrorResponseNull),
224    UnknownValue(serde_json::Value),
225}
226
227/// struct for typed errors of method [`get_user_user`]
228#[derive(Debug, Clone, Serialize, Deserialize)]
229#[serde(untagged)]
230pub enum GetUserUserError {
231    Status400(models::JsonErrorResponseNull),
232    Status401(models::JsonErrorResponseNull),
233    Status403(models::JsonErrorResponseNull),
234    Status404(models::JsonErrorResponseNull),
235    Status409(models::JsonErrorResponseNull),
236    Status429(models::JsonErrorResponseNull),
237    Status500(models::JsonErrorResponseNull),
238    UnknownValue(serde_json::Value),
239}
240
241/// struct for typed errors of method [`patch_two_factor`]
242#[derive(Debug, Clone, Serialize, Deserialize)]
243#[serde(untagged)]
244pub enum PatchTwoFactorError {
245    Status400(models::JsonErrorResponseNull),
246    Status401(models::JsonErrorResponseNull),
247    Status403(models::JsonErrorResponseNull),
248    Status404(models::JsonErrorResponseNull),
249    Status409(models::JsonErrorResponseNull),
250    Status429(models::JsonErrorResponseNull),
251    Status500(models::JsonErrorResponseNull),
252    UnknownValue(serde_json::Value),
253}
254
255/// struct for typed errors of method [`patch_user_user`]
256#[derive(Debug, Clone, Serialize, Deserialize)]
257#[serde(untagged)]
258pub enum PatchUserUserError {
259    Status400(models::JsonErrorResponseNull),
260    Status401(models::JsonErrorResponseNull),
261    Status403(models::JsonErrorResponseNull),
262    Status404(models::JsonErrorResponseNull),
263    Status409(models::JsonErrorResponseNull),
264    Status429(models::JsonErrorResponseNull),
265    Status500(models::JsonErrorResponseNull),
266    UnknownValue(serde_json::Value),
267}
268
269/// struct for typed errors of method [`post_public_key`]
270#[derive(Debug, Clone, Serialize, Deserialize)]
271#[serde(untagged)]
272pub enum PostPublicKeyError {
273    Status400(models::JsonErrorResponseNull),
274    Status401(models::JsonErrorResponseNull),
275    Status403(models::JsonErrorResponseNull),
276    Status404(models::JsonErrorResponseNull),
277    Status409(models::JsonErrorResponseNull),
278    Status429(models::JsonErrorResponseNull),
279    Status500(models::JsonErrorResponseNull),
280    UnknownValue(serde_json::Value),
281}
282
283/// struct for typed errors of method [`post_token`]
284#[derive(Debug, Clone, Serialize, Deserialize)]
285#[serde(untagged)]
286pub enum PostTokenError {
287    Status400(models::JsonErrorResponseNull),
288    Status401(models::JsonErrorResponseNull),
289    Status403(models::JsonErrorResponseNull),
290    Status404(models::JsonErrorResponseNull),
291    Status409(models::JsonErrorResponseNull),
292    Status429(models::JsonErrorResponseNull),
293    Status500(models::JsonErrorResponseNull),
294    UnknownValue(serde_json::Value),
295}
296
297/// struct for typed errors of method [`post_two_factor`]
298#[derive(Debug, Clone, Serialize, Deserialize)]
299#[serde(untagged)]
300pub enum PostTwoFactorError {
301    Status400(models::JsonErrorResponseNull),
302    Status401(models::JsonErrorResponseNull),
303    Status403(models::JsonErrorResponseNull),
304    Status404(models::JsonErrorResponseNull),
305    Status409(models::JsonErrorResponseNull),
306    Status429(models::JsonErrorResponseNull),
307    Status500(models::JsonErrorResponseNull),
308    UnknownValue(serde_json::Value),
309}
310
311pub async fn delete_public_key(
312    configuration: &configuration::Configuration,
313    public_key_name: &str,
314) -> Result<(), Error<DeletePublicKeyError>> {
315    // add a prefix to parameters to efficiently prevent name collisions
316    let p_path_public_key_name = public_key_name;
317
318    let uri_str = format!(
319        "{}/user/keys/{public_key_name}",
320        configuration.base_path,
321        public_key_name = crate::apis::urlencode(p_path_public_key_name)
322    );
323    let mut req_builder = configuration
324        .client
325        .request(reqwest::Method::DELETE, &uri_str);
326
327    if let Some(ref apikey) = configuration.api_key {
328        let key = apikey.key.clone();
329        let value = match apikey.prefix {
330            Some(ref prefix) => format!("{} {}", prefix, key),
331            None => key,
332        };
333        req_builder = req_builder.query(&[("access_token", value)]);
334    }
335    if let Some(ref user_agent) = configuration.user_agent {
336        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
337    }
338    if let Some(ref auth_conf) = configuration.basic_auth {
339        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
340    };
341    if let Some(ref token) = configuration.bearer_access_token {
342        req_builder = req_builder.bearer_auth(token.to_owned());
343    };
344
345    let req = req_builder.build()?;
346    let resp = configuration.client.execute(req).await?;
347
348    let status = resp.status();
349
350    if !status.is_client_error() && !status.is_server_error() {
351        Ok(())
352    } else {
353        let content = resp.text().await?;
354        let entity: Option<DeletePublicKeyError> = serde_json::from_str(&content).ok();
355        Err(Error::ResponseError(ResponseContent {
356            status,
357            content,
358            entity,
359        }))
360    }
361}
362
363pub async fn delete_session(
364    configuration: &configuration::Configuration,
365    session_name: &str,
366) -> Result<(), Error<DeleteSessionError>> {
367    // add a prefix to parameters to efficiently prevent name collisions
368    let p_path_session_name = session_name;
369
370    let uri_str = format!(
371        "{}/user/sessions/{session_name}",
372        configuration.base_path,
373        session_name = crate::apis::urlencode(p_path_session_name)
374    );
375    let mut req_builder = configuration
376        .client
377        .request(reqwest::Method::DELETE, &uri_str);
378
379    if let Some(ref apikey) = configuration.api_key {
380        let key = apikey.key.clone();
381        let value = match apikey.prefix {
382            Some(ref prefix) => format!("{} {}", prefix, key),
383            None => key,
384        };
385        req_builder = req_builder.query(&[("access_token", value)]);
386    }
387    if let Some(ref user_agent) = configuration.user_agent {
388        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
389    }
390    if let Some(ref auth_conf) = configuration.basic_auth {
391        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
392    };
393    if let Some(ref token) = configuration.bearer_access_token {
394        req_builder = req_builder.bearer_auth(token.to_owned());
395    };
396
397    let req = req_builder.build()?;
398    let resp = configuration.client.execute(req).await?;
399
400    let status = resp.status();
401
402    if !status.is_client_error() && !status.is_server_error() {
403        Ok(())
404    } else {
405        let content = resp.text().await?;
406        let entity: Option<DeleteSessionError> = serde_json::from_str(&content).ok();
407        Err(Error::ResponseError(ResponseContent {
408            status,
409            content,
410            entity,
411        }))
412    }
413}
414
415pub async fn delete_token(
416    configuration: &configuration::Configuration,
417    token_name: &str,
418) -> Result<(), Error<DeleteTokenError>> {
419    // add a prefix to parameters to efficiently prevent name collisions
420    let p_path_token_name = token_name;
421
422    let uri_str = format!(
423        "{}/user/tokens/{token_name}",
424        configuration.base_path,
425        token_name = crate::apis::urlencode(p_path_token_name)
426    );
427    let mut req_builder = configuration
428        .client
429        .request(reqwest::Method::DELETE, &uri_str);
430
431    if let Some(ref apikey) = configuration.api_key {
432        let key = apikey.key.clone();
433        let value = match apikey.prefix {
434            Some(ref prefix) => format!("{} {}", prefix, key),
435            None => key,
436        };
437        req_builder = req_builder.query(&[("access_token", value)]);
438    }
439    if let Some(ref user_agent) = configuration.user_agent {
440        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
441    }
442    if let Some(ref auth_conf) = configuration.basic_auth {
443        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
444    };
445    if let Some(ref token) = configuration.bearer_access_token {
446        req_builder = req_builder.bearer_auth(token.to_owned());
447    };
448
449    let req = req_builder.build()?;
450    let resp = configuration.client.execute(req).await?;
451
452    let status = resp.status();
453
454    if !status.is_client_error() && !status.is_server_error() {
455        Ok(())
456    } else {
457        let content = resp.text().await?;
458        let entity: Option<DeleteTokenError> = serde_json::from_str(&content).ok();
459        Err(Error::ResponseError(ResponseContent {
460            status,
461            content,
462            entity,
463        }))
464    }
465}
466
467pub async fn delete_two_factor(
468    configuration: &configuration::Configuration,
469) -> Result<(), Error<DeleteTwoFactorError>> {
470    let uri_str = format!("{}/user/security/two_factor", configuration.base_path);
471    let mut req_builder = configuration
472        .client
473        .request(reqwest::Method::DELETE, &uri_str);
474
475    if let Some(ref apikey) = configuration.api_key {
476        let key = apikey.key.clone();
477        let value = match apikey.prefix {
478            Some(ref prefix) => format!("{} {}", prefix, key),
479            None => key,
480        };
481        req_builder = req_builder.query(&[("access_token", value)]);
482    }
483    if let Some(ref user_agent) = configuration.user_agent {
484        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
485    }
486    if let Some(ref auth_conf) = configuration.basic_auth {
487        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
488    };
489    if let Some(ref token) = configuration.bearer_access_token {
490        req_builder = req_builder.bearer_auth(token.to_owned());
491    };
492
493    let req = req_builder.build()?;
494    let resp = configuration.client.execute(req).await?;
495
496    let status = resp.status();
497
498    if !status.is_client_error() && !status.is_server_error() {
499        Ok(())
500    } else {
501        let content = resp.text().await?;
502        let entity: Option<DeleteTwoFactorError> = serde_json::from_str(&content).ok();
503        Err(Error::ResponseError(ResponseContent {
504            status,
505            content,
506            entity,
507        }))
508    }
509}
510
511pub async fn get_feeds(
512    configuration: &configuration::Configuration,
513    page: Option<i64>,
514    size: Option<i64>,
515    order: Option<models::OrderOption>,
516    r#type: Option<models::FeedType>,
517    before: Option<i64>,
518    after: Option<i64>,
519) -> Result<Vec<models::FeedRelations>, Error<GetFeedsError>> {
520    // add a prefix to parameters to efficiently prevent name collisions
521    let p_query_page = page;
522    let p_query_size = size;
523    let p_query_order = order;
524    let p_query_type = r#type;
525    let p_query_before = before;
526    let p_query_after = after;
527
528    let uri_str = format!("{}/user/feeds", configuration.base_path);
529    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
530
531    if let Some(ref param_value) = p_query_page {
532        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
533    }
534    if let Some(ref param_value) = p_query_size {
535        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
536    }
537    if let Some(ref param_value) = p_query_order {
538        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
539    }
540    if let Some(ref param_value) = p_query_type {
541        req_builder = req_builder.query(&[("type", &param_value.to_string())]);
542    }
543    if let Some(ref param_value) = p_query_before {
544        req_builder = req_builder.query(&[("before", &param_value.to_string())]);
545    }
546    if let Some(ref param_value) = p_query_after {
547        req_builder = req_builder.query(&[("after", &param_value.to_string())]);
548    }
549    if let Some(ref apikey) = configuration.api_key {
550        let key = apikey.key.clone();
551        let value = match apikey.prefix {
552            Some(ref prefix) => format!("{} {}", prefix, key),
553            None => key,
554        };
555        req_builder = req_builder.query(&[("access_token", value)]);
556    }
557    if let Some(ref user_agent) = configuration.user_agent {
558        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
559    }
560    if let Some(ref auth_conf) = configuration.basic_auth {
561        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
562    };
563    if let Some(ref token) = configuration.bearer_access_token {
564        req_builder = req_builder.bearer_auth(token.to_owned());
565    };
566
567    let req = req_builder.build()?;
568    let resp = configuration.client.execute(req).await?;
569
570    let status = resp.status();
571    let content_type = resp
572        .headers()
573        .get("content-type")
574        .and_then(|v| v.to_str().ok())
575        .unwrap_or("application/octet-stream");
576    let content_type = super::ContentType::from(content_type);
577
578    if !status.is_client_error() && !status.is_server_error() {
579        let content = resp.text().await?;
580        match content_type {
581            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
582            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::FeedRelations&gt;`"))),
583            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::FeedRelations&gt;`")))),
584        }
585    } else {
586        let content = resp.text().await?;
587        let entity: Option<GetFeedsError> = serde_json::from_str(&content).ok();
588        Err(Error::ResponseError(ResponseContent {
589            status,
590            content,
591            entity,
592        }))
593    }
594}
595
596pub async fn get_has_perm(
597    configuration: &configuration::Configuration,
598    repo_ref: &str,
599    perm: models::Permission,
600) -> Result<bool, Error<GetHasPermError>> {
601    // add a prefix to parameters to efficiently prevent name collisions
602    let p_path_repo_ref = repo_ref;
603    let p_query_perm = perm;
604
605    let uri_str = format!(
606        "{}/user/{repo_ref}/+/has_perm",
607        configuration.base_path,
608        repo_ref = crate::apis::urlencode(p_path_repo_ref)
609    );
610    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
611
612    req_builder = req_builder.query(&[("perm", &p_query_perm.to_string())]);
613    if let Some(ref apikey) = configuration.api_key {
614        let key = apikey.key.clone();
615        let value = match apikey.prefix {
616            Some(ref prefix) => format!("{} {}", prefix, key),
617            None => key,
618        };
619        req_builder = req_builder.query(&[("access_token", value)]);
620    }
621    if let Some(ref user_agent) = configuration.user_agent {
622        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
623    }
624    if let Some(ref auth_conf) = configuration.basic_auth {
625        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
626    };
627    if let Some(ref token) = configuration.bearer_access_token {
628        req_builder = req_builder.bearer_auth(token.to_owned());
629    };
630
631    let req = req_builder.build()?;
632    let resp = configuration.client.execute(req).await?;
633
634    let status = resp.status();
635    let content_type = resp
636        .headers()
637        .get("content-type")
638        .and_then(|v| v.to_str().ok())
639        .unwrap_or("application/octet-stream");
640    let content_type = super::ContentType::from(content_type);
641
642    if !status.is_client_error() && !status.is_server_error() {
643        let content = resp.text().await?;
644        match content_type {
645            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
646            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))),
647            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))),
648        }
649    } else {
650        let content = resp.text().await?;
651        let entity: Option<GetHasPermError> = serde_json::from_str(&content).ok();
652        Err(Error::ResponseError(ResponseContent {
653            status,
654            content,
655            entity,
656        }))
657    }
658}
659
660pub async fn get_heatmap(
661    configuration: &configuration::Configuration,
662    before: Option<i64>,
663    after: Option<i64>,
664) -> Result<models::Heatmap, Error<GetHeatmapError>> {
665    // add a prefix to parameters to efficiently prevent name collisions
666    let p_query_before = before;
667    let p_query_after = after;
668
669    let uri_str = format!("{}/user/heatmap", configuration.base_path);
670    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
671
672    if let Some(ref param_value) = p_query_before {
673        req_builder = req_builder.query(&[("before", &param_value.to_string())]);
674    }
675    if let Some(ref param_value) = p_query_after {
676        req_builder = req_builder.query(&[("after", &param_value.to_string())]);
677    }
678    if let Some(ref apikey) = configuration.api_key {
679        let key = apikey.key.clone();
680        let value = match apikey.prefix {
681            Some(ref prefix) => format!("{} {}", prefix, key),
682            None => key,
683        };
684        req_builder = req_builder.query(&[("access_token", value)]);
685    }
686    if let Some(ref user_agent) = configuration.user_agent {
687        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
688    }
689    if let Some(ref auth_conf) = configuration.basic_auth {
690        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
691    };
692    if let Some(ref token) = configuration.bearer_access_token {
693        req_builder = req_builder.bearer_auth(token.to_owned());
694    };
695
696    let req = req_builder.build()?;
697    let resp = configuration.client.execute(req).await?;
698
699    let status = resp.status();
700    let content_type = resp
701        .headers()
702        .get("content-type")
703        .and_then(|v| v.to_str().ok())
704        .unwrap_or("application/octet-stream");
705    let content_type = super::ContentType::from(content_type);
706
707    if !status.is_client_error() && !status.is_server_error() {
708        let content = resp.text().await?;
709        match content_type {
710            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
711            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Heatmap`"))),
712            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Heatmap`")))),
713        }
714    } else {
715        let content = resp.text().await?;
716        let entity: Option<GetHeatmapError> = serde_json::from_str(&content).ok();
717        Err(Error::ResponseError(ResponseContent {
718            status,
719            content,
720            entity,
721        }))
722    }
723}
724
725pub async fn get_memberships(
726    configuration: &configuration::Configuration,
727    page: Option<i64>,
728    size: Option<i64>,
729    query: Option<&str>,
730    sort: Option<models::MembershipSort>,
731    order: Option<models::OrderOption>,
732) -> Result<Vec<models::MembershipGroup>, Error<GetMembershipsError>> {
733    // add a prefix to parameters to efficiently prevent name collisions
734    let p_query_page = page;
735    let p_query_size = size;
736    let p_query_query = query;
737    let p_query_sort = sort;
738    let p_query_order = order;
739
740    let uri_str = format!("{}/user/memberships", configuration.base_path);
741    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
742
743    if let Some(ref param_value) = p_query_page {
744        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
745    }
746    if let Some(ref param_value) = p_query_size {
747        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
748    }
749    if let Some(ref param_value) = p_query_query {
750        req_builder = req_builder.query(&[("query", &param_value.to_string())]);
751    }
752    if let Some(ref param_value) = p_query_sort {
753        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
754    }
755    if let Some(ref param_value) = p_query_order {
756        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
757    }
758    if let Some(ref apikey) = configuration.api_key {
759        let key = apikey.key.clone();
760        let value = match apikey.prefix {
761            Some(ref prefix) => format!("{} {}", prefix, key),
762            None => key,
763        };
764        req_builder = req_builder.query(&[("access_token", value)]);
765    }
766    if let Some(ref user_agent) = configuration.user_agent {
767        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
768    }
769    if let Some(ref auth_conf) = configuration.basic_auth {
770        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
771    };
772    if let Some(ref token) = configuration.bearer_access_token {
773        req_builder = req_builder.bearer_auth(token.to_owned());
774    };
775
776    let req = req_builder.build()?;
777    let resp = configuration.client.execute(req).await?;
778
779    let status = resp.status();
780    let content_type = resp
781        .headers()
782        .get("content-type")
783        .and_then(|v| v.to_str().ok())
784        .unwrap_or("application/octet-stream");
785    let content_type = super::ContentType::from(content_type);
786
787    if !status.is_client_error() && !status.is_server_error() {
788        let content = resp.text().await?;
789        match content_type {
790            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
791            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::MembershipGroup&gt;`"))),
792            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::MembershipGroup&gt;`")))),
793        }
794    } else {
795        let content = resp.text().await?;
796        let entity: Option<GetMembershipsError> = serde_json::from_str(&content).ok();
797        Err(Error::ResponseError(ResponseContent {
798            status,
799            content,
800            entity,
801        }))
802    }
803}
804
805pub async fn get_public_keys(
806    configuration: &configuration::Configuration,
807    page: Option<i64>,
808    size: Option<i64>,
809    query: Option<&str>,
810    sort: Option<models::PublicKeySort>,
811    order: Option<models::OrderOption>,
812) -> Result<Vec<models::PublicKeyModel>, Error<GetPublicKeysError>> {
813    // add a prefix to parameters to efficiently prevent name collisions
814    let p_query_page = page;
815    let p_query_size = size;
816    let p_query_query = query;
817    let p_query_sort = sort;
818    let p_query_order = order;
819
820    let uri_str = format!("{}/user/keys", configuration.base_path);
821    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
822
823    if let Some(ref param_value) = p_query_page {
824        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
825    }
826    if let Some(ref param_value) = p_query_size {
827        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
828    }
829    if let Some(ref param_value) = p_query_query {
830        req_builder = req_builder.query(&[("query", &param_value.to_string())]);
831    }
832    if let Some(ref param_value) = p_query_sort {
833        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
834    }
835    if let Some(ref param_value) = p_query_order {
836        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
837    }
838    if let Some(ref apikey) = configuration.api_key {
839        let key = apikey.key.clone();
840        let value = match apikey.prefix {
841            Some(ref prefix) => format!("{} {}", prefix, key),
842            None => key,
843        };
844        req_builder = req_builder.query(&[("access_token", value)]);
845    }
846    if let Some(ref user_agent) = configuration.user_agent {
847        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
848    }
849    if let Some(ref auth_conf) = configuration.basic_auth {
850        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
851    };
852    if let Some(ref token) = configuration.bearer_access_token {
853        req_builder = req_builder.bearer_auth(token.to_owned());
854    };
855
856    let req = req_builder.build()?;
857    let resp = configuration.client.execute(req).await?;
858
859    let status = resp.status();
860    let content_type = resp
861        .headers()
862        .get("content-type")
863        .and_then(|v| v.to_str().ok())
864        .unwrap_or("application/octet-stream");
865    let content_type = super::ContentType::from(content_type);
866
867    if !status.is_client_error() && !status.is_server_error() {
868        let content = resp.text().await?;
869        match content_type {
870            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
871            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::PublicKeyModel&gt;`"))),
872            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::PublicKeyModel&gt;`")))),
873        }
874    } else {
875        let content = resp.text().await?;
876        let entity: Option<GetPublicKeysError> = serde_json::from_str(&content).ok();
877        Err(Error::ResponseError(ResponseContent {
878            status,
879            content,
880            entity,
881        }))
882    }
883}
884
885pub async fn get_sessions(
886    configuration: &configuration::Configuration,
887) -> Result<Vec<models::TokenModel>, Error<GetSessionsError>> {
888    let uri_str = format!("{}/user/sessions", configuration.base_path);
889    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
890
891    if let Some(ref apikey) = configuration.api_key {
892        let key = apikey.key.clone();
893        let value = match apikey.prefix {
894            Some(ref prefix) => format!("{} {}", prefix, key),
895            None => key,
896        };
897        req_builder = req_builder.query(&[("access_token", value)]);
898    }
899    if let Some(ref user_agent) = configuration.user_agent {
900        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
901    }
902    if let Some(ref auth_conf) = configuration.basic_auth {
903        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
904    };
905    if let Some(ref token) = configuration.bearer_access_token {
906        req_builder = req_builder.bearer_auth(token.to_owned());
907    };
908
909    let req = req_builder.build()?;
910    let resp = configuration.client.execute(req).await?;
911
912    let status = resp.status();
913    let content_type = resp
914        .headers()
915        .get("content-type")
916        .and_then(|v| v.to_str().ok())
917        .unwrap_or("application/octet-stream");
918    let content_type = super::ContentType::from(content_type);
919
920    if !status.is_client_error() && !status.is_server_error() {
921        let content = resp.text().await?;
922        match content_type {
923            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
924            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::TokenModel&gt;`"))),
925            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::TokenModel&gt;`")))),
926        }
927    } else {
928        let content = resp.text().await?;
929        let entity: Option<GetSessionsError> = serde_json::from_str(&content).ok();
930        Err(Error::ResponseError(ResponseContent {
931            status,
932            content,
933            entity,
934        }))
935    }
936}
937
938pub async fn get_tokens(
939    configuration: &configuration::Configuration,
940) -> Result<Vec<models::TokenModel>, Error<GetTokensError>> {
941    let uri_str = format!("{}/user/tokens", configuration.base_path);
942    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
943
944    if let Some(ref apikey) = configuration.api_key {
945        let key = apikey.key.clone();
946        let value = match apikey.prefix {
947            Some(ref prefix) => format!("{} {}", prefix, key),
948            None => key,
949        };
950        req_builder = req_builder.query(&[("access_token", value)]);
951    }
952    if let Some(ref user_agent) = configuration.user_agent {
953        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
954    }
955    if let Some(ref auth_conf) = configuration.basic_auth {
956        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
957    };
958    if let Some(ref token) = configuration.bearer_access_token {
959        req_builder = req_builder.bearer_auth(token.to_owned());
960    };
961
962    let req = req_builder.build()?;
963    let resp = configuration.client.execute(req).await?;
964
965    let status = resp.status();
966    let content_type = resp
967        .headers()
968        .get("content-type")
969        .and_then(|v| v.to_str().ok())
970        .unwrap_or("application/octet-stream");
971    let content_type = super::ContentType::from(content_type);
972
973    if !status.is_client_error() && !status.is_server_error() {
974        let content = resp.text().await?;
975        match content_type {
976            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
977            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::TokenModel&gt;`"))),
978            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::TokenModel&gt;`")))),
979        }
980    } else {
981        let content = resp.text().await?;
982        let entity: Option<GetTokensError> = serde_json::from_str(&content).ok();
983        Err(Error::ResponseError(ResponseContent {
984            status,
985            content,
986            entity,
987        }))
988    }
989}
990
991pub async fn get_two_factor(
992    configuration: &configuration::Configuration,
993) -> Result<models::TwoFactorGetOutput, Error<GetTwoFactorError>> {
994    let uri_str = format!("{}/user/security/two_factor", configuration.base_path);
995    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
996
997    if let Some(ref apikey) = configuration.api_key {
998        let key = apikey.key.clone();
999        let value = match apikey.prefix {
1000            Some(ref prefix) => format!("{} {}", prefix, key),
1001            None => key,
1002        };
1003        req_builder = req_builder.query(&[("access_token", value)]);
1004    }
1005    if let Some(ref user_agent) = configuration.user_agent {
1006        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1007    }
1008    if let Some(ref auth_conf) = configuration.basic_auth {
1009        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
1010    };
1011    if let Some(ref token) = configuration.bearer_access_token {
1012        req_builder = req_builder.bearer_auth(token.to_owned());
1013    };
1014
1015    let req = req_builder.build()?;
1016    let resp = configuration.client.execute(req).await?;
1017
1018    let status = resp.status();
1019    let content_type = resp
1020        .headers()
1021        .get("content-type")
1022        .and_then(|v| v.to_str().ok())
1023        .unwrap_or("application/octet-stream");
1024    let content_type = super::ContentType::from(content_type);
1025
1026    if !status.is_client_error() && !status.is_server_error() {
1027        let content = resp.text().await?;
1028        match content_type {
1029            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1030            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TwoFactorGetOutput`"))),
1031            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TwoFactorGetOutput`")))),
1032        }
1033    } else {
1034        let content = resp.text().await?;
1035        let entity: Option<GetTwoFactorError> = serde_json::from_str(&content).ok();
1036        Err(Error::ResponseError(ResponseContent {
1037            status,
1038            content,
1039            entity,
1040        }))
1041    }
1042}
1043
1044pub async fn get_user_groups(
1045    configuration: &configuration::Configuration,
1046    page: Option<i64>,
1047    size: Option<i64>,
1048    query: Option<&str>,
1049    sort: Option<models::GroupSort>,
1050    order: Option<models::OrderOption>,
1051) -> Result<Vec<models::GroupModel>, Error<GetUserGroupsError>> {
1052    // add a prefix to parameters to efficiently prevent name collisions
1053    let p_query_page = page;
1054    let p_query_size = size;
1055    let p_query_query = query;
1056    let p_query_sort = sort;
1057    let p_query_order = order;
1058
1059    let uri_str = format!("{}/user/groups", configuration.base_path);
1060    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1061
1062    if let Some(ref param_value) = p_query_page {
1063        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
1064    }
1065    if let Some(ref param_value) = p_query_size {
1066        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
1067    }
1068    if let Some(ref param_value) = p_query_query {
1069        req_builder = req_builder.query(&[("query", &param_value.to_string())]);
1070    }
1071    if let Some(ref param_value) = p_query_sort {
1072        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
1073    }
1074    if let Some(ref param_value) = p_query_order {
1075        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
1076    }
1077    if let Some(ref apikey) = configuration.api_key {
1078        let key = apikey.key.clone();
1079        let value = match apikey.prefix {
1080            Some(ref prefix) => format!("{} {}", prefix, key),
1081            None => key,
1082        };
1083        req_builder = req_builder.query(&[("access_token", value)]);
1084    }
1085    if let Some(ref user_agent) = configuration.user_agent {
1086        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1087    }
1088    if let Some(ref auth_conf) = configuration.basic_auth {
1089        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
1090    };
1091    if let Some(ref token) = configuration.bearer_access_token {
1092        req_builder = req_builder.bearer_auth(token.to_owned());
1093    };
1094
1095    let req = req_builder.build()?;
1096    let resp = configuration.client.execute(req).await?;
1097
1098    let status = resp.status();
1099    let content_type = resp
1100        .headers()
1101        .get("content-type")
1102        .and_then(|v| v.to_str().ok())
1103        .unwrap_or("application/octet-stream");
1104    let content_type = super::ContentType::from(content_type);
1105
1106    if !status.is_client_error() && !status.is_server_error() {
1107        let content = resp.text().await?;
1108        match content_type {
1109            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1110            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::GroupModel&gt;`"))),
1111            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::GroupModel&gt;`")))),
1112        }
1113    } else {
1114        let content = resp.text().await?;
1115        let entity: Option<GetUserGroupsError> = serde_json::from_str(&content).ok();
1116        Err(Error::ResponseError(ResponseContent {
1117            status,
1118            content,
1119            entity,
1120        }))
1121    }
1122}
1123
1124pub async fn get_user_repos(
1125    configuration: &configuration::Configuration,
1126    page: Option<i64>,
1127    size: Option<i64>,
1128    query: Option<&str>,
1129    sort: Option<models::RepoSort>,
1130    order: Option<models::OrderOption>,
1131) -> Result<Vec<models::RepoParent>, Error<GetUserReposError>> {
1132    // add a prefix to parameters to efficiently prevent name collisions
1133    let p_query_page = page;
1134    let p_query_size = size;
1135    let p_query_query = query;
1136    let p_query_sort = sort;
1137    let p_query_order = order;
1138
1139    let uri_str = format!("{}/user/repos", configuration.base_path);
1140    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1141
1142    if let Some(ref param_value) = p_query_page {
1143        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
1144    }
1145    if let Some(ref param_value) = p_query_size {
1146        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
1147    }
1148    if let Some(ref param_value) = p_query_query {
1149        req_builder = req_builder.query(&[("query", &param_value.to_string())]);
1150    }
1151    if let Some(ref param_value) = p_query_sort {
1152        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
1153    }
1154    if let Some(ref param_value) = p_query_order {
1155        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
1156    }
1157    if let Some(ref apikey) = configuration.api_key {
1158        let key = apikey.key.clone();
1159        let value = match apikey.prefix {
1160            Some(ref prefix) => format!("{} {}", prefix, key),
1161            None => key,
1162        };
1163        req_builder = req_builder.query(&[("access_token", value)]);
1164    }
1165    if let Some(ref user_agent) = configuration.user_agent {
1166        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1167    }
1168    if let Some(ref auth_conf) = configuration.basic_auth {
1169        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
1170    };
1171    if let Some(ref token) = configuration.bearer_access_token {
1172        req_builder = req_builder.bearer_auth(token.to_owned());
1173    };
1174
1175    let req = req_builder.build()?;
1176    let resp = configuration.client.execute(req).await?;
1177
1178    let status = resp.status();
1179    let content_type = resp
1180        .headers()
1181        .get("content-type")
1182        .and_then(|v| v.to_str().ok())
1183        .unwrap_or("application/octet-stream");
1184    let content_type = super::ContentType::from(content_type);
1185
1186    if !status.is_client_error() && !status.is_server_error() {
1187        let content = resp.text().await?;
1188        match content_type {
1189            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1190            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::RepoParent&gt;`"))),
1191            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::RepoParent&gt;`")))),
1192        }
1193    } else {
1194        let content = resp.text().await?;
1195        let entity: Option<GetUserReposError> = serde_json::from_str(&content).ok();
1196        Err(Error::ResponseError(ResponseContent {
1197            status,
1198            content,
1199            entity,
1200        }))
1201    }
1202}
1203
1204pub async fn get_user_stars(
1205    configuration: &configuration::Configuration,
1206    page: Option<i64>,
1207    size: Option<i64>,
1208    query: Option<&str>,
1209    sort: Option<models::RepoSort>,
1210    order: Option<models::OrderOption>,
1211) -> Result<Vec<models::RepoParent>, Error<GetUserStarsError>> {
1212    // add a prefix to parameters to efficiently prevent name collisions
1213    let p_query_page = page;
1214    let p_query_size = size;
1215    let p_query_query = query;
1216    let p_query_sort = sort;
1217    let p_query_order = order;
1218
1219    let uri_str = format!("{}/user/stars", configuration.base_path);
1220    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1221
1222    if let Some(ref param_value) = p_query_page {
1223        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
1224    }
1225    if let Some(ref param_value) = p_query_size {
1226        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
1227    }
1228    if let Some(ref param_value) = p_query_query {
1229        req_builder = req_builder.query(&[("query", &param_value.to_string())]);
1230    }
1231    if let Some(ref param_value) = p_query_sort {
1232        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
1233    }
1234    if let Some(ref param_value) = p_query_order {
1235        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
1236    }
1237    if let Some(ref apikey) = configuration.api_key {
1238        let key = apikey.key.clone();
1239        let value = match apikey.prefix {
1240            Some(ref prefix) => format!("{} {}", prefix, key),
1241            None => key,
1242        };
1243        req_builder = req_builder.query(&[("access_token", value)]);
1244    }
1245    if let Some(ref user_agent) = configuration.user_agent {
1246        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1247    }
1248    if let Some(ref auth_conf) = configuration.basic_auth {
1249        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
1250    };
1251    if let Some(ref token) = configuration.bearer_access_token {
1252        req_builder = req_builder.bearer_auth(token.to_owned());
1253    };
1254
1255    let req = req_builder.build()?;
1256    let resp = configuration.client.execute(req).await?;
1257
1258    let status = resp.status();
1259    let content_type = resp
1260        .headers()
1261        .get("content-type")
1262        .and_then(|v| v.to_str().ok())
1263        .unwrap_or("application/octet-stream");
1264    let content_type = super::ContentType::from(content_type);
1265
1266    if !status.is_client_error() && !status.is_server_error() {
1267        let content = resp.text().await?;
1268        match content_type {
1269            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1270            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::RepoParent&gt;`"))),
1271            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::RepoParent&gt;`")))),
1272        }
1273    } else {
1274        let content = resp.text().await?;
1275        let entity: Option<GetUserStarsError> = serde_json::from_str(&content).ok();
1276        Err(Error::ResponseError(ResponseContent {
1277            status,
1278            content,
1279            entity,
1280        }))
1281    }
1282}
1283
1284pub async fn get_user_user(
1285    configuration: &configuration::Configuration,
1286) -> Result<models::UserModel, Error<GetUserUserError>> {
1287    let uri_str = format!("{}/user", configuration.base_path);
1288    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1289
1290    if let Some(ref apikey) = configuration.api_key {
1291        let key = apikey.key.clone();
1292        let value = match apikey.prefix {
1293            Some(ref prefix) => format!("{} {}", prefix, key),
1294            None => key,
1295        };
1296        req_builder = req_builder.query(&[("access_token", value)]);
1297    }
1298    if let Some(ref user_agent) = configuration.user_agent {
1299        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1300    }
1301    if let Some(ref auth_conf) = configuration.basic_auth {
1302        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
1303    };
1304    if let Some(ref token) = configuration.bearer_access_token {
1305        req_builder = req_builder.bearer_auth(token.to_owned());
1306    };
1307
1308    let req = req_builder.build()?;
1309    let resp = configuration.client.execute(req).await?;
1310
1311    let status = resp.status();
1312    let content_type = resp
1313        .headers()
1314        .get("content-type")
1315        .and_then(|v| v.to_str().ok())
1316        .unwrap_or("application/octet-stream");
1317    let content_type = super::ContentType::from(content_type);
1318
1319    if !status.is_client_error() && !status.is_server_error() {
1320        let content = resp.text().await?;
1321        match content_type {
1322            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1323            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UserModel`"))),
1324            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UserModel`")))),
1325        }
1326    } else {
1327        let content = resp.text().await?;
1328        let entity: Option<GetUserUserError> = serde_json::from_str(&content).ok();
1329        Err(Error::ResponseError(ResponseContent {
1330            status,
1331            content,
1332            entity,
1333        }))
1334    }
1335}
1336
1337pub async fn patch_two_factor(
1338    configuration: &configuration::Configuration,
1339) -> Result<String, Error<PatchTwoFactorError>> {
1340    let uri_str = format!("{}/user/security/two_factor", configuration.base_path);
1341    let mut req_builder = configuration
1342        .client
1343        .request(reqwest::Method::PATCH, &uri_str);
1344
1345    if let Some(ref apikey) = configuration.api_key {
1346        let key = apikey.key.clone();
1347        let value = match apikey.prefix {
1348            Some(ref prefix) => format!("{} {}", prefix, key),
1349            None => key,
1350        };
1351        req_builder = req_builder.query(&[("access_token", value)]);
1352    }
1353    if let Some(ref user_agent) = configuration.user_agent {
1354        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1355    }
1356    if let Some(ref auth_conf) = configuration.basic_auth {
1357        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
1358    };
1359    if let Some(ref token) = configuration.bearer_access_token {
1360        req_builder = req_builder.bearer_auth(token.to_owned());
1361    };
1362
1363    let req = req_builder.build()?;
1364    let resp = configuration.client.execute(req).await?;
1365
1366    let status = resp.status();
1367    let content_type = resp
1368        .headers()
1369        .get("content-type")
1370        .and_then(|v| v.to_str().ok())
1371        .unwrap_or("application/octet-stream");
1372    let content_type = super::ContentType::from(content_type);
1373
1374    if !status.is_client_error() && !status.is_server_error() {
1375        let content = resp.text().await?;
1376        match content_type {
1377            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1378            ContentType::Text => Ok(content),
1379            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `String`")))),
1380        }
1381    } else {
1382        let content = resp.text().await?;
1383        let entity: Option<PatchTwoFactorError> = serde_json::from_str(&content).ok();
1384        Err(Error::ResponseError(ResponseContent {
1385            status,
1386            content,
1387            entity,
1388        }))
1389    }
1390}
1391
1392pub async fn patch_user_user(
1393    configuration: &configuration::Configuration,
1394    user_patch_input: models::UserPatchInput,
1395) -> Result<models::UserModel, Error<PatchUserUserError>> {
1396    // add a prefix to parameters to efficiently prevent name collisions
1397    let p_body_user_patch_input = user_patch_input;
1398
1399    let uri_str = format!("{}/user", configuration.base_path);
1400    let mut req_builder = configuration
1401        .client
1402        .request(reqwest::Method::PATCH, &uri_str);
1403
1404    if let Some(ref apikey) = configuration.api_key {
1405        let key = apikey.key.clone();
1406        let value = match apikey.prefix {
1407            Some(ref prefix) => format!("{} {}", prefix, key),
1408            None => key,
1409        };
1410        req_builder = req_builder.query(&[("access_token", value)]);
1411    }
1412    if let Some(ref user_agent) = configuration.user_agent {
1413        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1414    }
1415    if let Some(ref auth_conf) = configuration.basic_auth {
1416        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
1417    };
1418    if let Some(ref token) = configuration.bearer_access_token {
1419        req_builder = req_builder.bearer_auth(token.to_owned());
1420    };
1421    req_builder = req_builder.json(&p_body_user_patch_input);
1422
1423    let req = req_builder.build()?;
1424    let resp = configuration.client.execute(req).await?;
1425
1426    let status = resp.status();
1427    let content_type = resp
1428        .headers()
1429        .get("content-type")
1430        .and_then(|v| v.to_str().ok())
1431        .unwrap_or("application/octet-stream");
1432    let content_type = super::ContentType::from(content_type);
1433
1434    if !status.is_client_error() && !status.is_server_error() {
1435        let content = resp.text().await?;
1436        match content_type {
1437            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1438            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UserModel`"))),
1439            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UserModel`")))),
1440        }
1441    } else {
1442        let content = resp.text().await?;
1443        let entity: Option<PatchUserUserError> = serde_json::from_str(&content).ok();
1444        Err(Error::ResponseError(ResponseContent {
1445            status,
1446            content,
1447            entity,
1448        }))
1449    }
1450}
1451
1452pub async fn post_public_key(
1453    configuration: &configuration::Configuration,
1454    public_key_create_input: models::PublicKeyCreateInput,
1455) -> Result<models::PublicKeyModel, Error<PostPublicKeyError>> {
1456    // add a prefix to parameters to efficiently prevent name collisions
1457    let p_body_public_key_create_input = public_key_create_input;
1458
1459    let uri_str = format!("{}/user/keys", configuration.base_path);
1460    let mut req_builder = configuration
1461        .client
1462        .request(reqwest::Method::POST, &uri_str);
1463
1464    if let Some(ref apikey) = configuration.api_key {
1465        let key = apikey.key.clone();
1466        let value = match apikey.prefix {
1467            Some(ref prefix) => format!("{} {}", prefix, key),
1468            None => key,
1469        };
1470        req_builder = req_builder.query(&[("access_token", value)]);
1471    }
1472    if let Some(ref user_agent) = configuration.user_agent {
1473        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1474    }
1475    if let Some(ref auth_conf) = configuration.basic_auth {
1476        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
1477    };
1478    if let Some(ref token) = configuration.bearer_access_token {
1479        req_builder = req_builder.bearer_auth(token.to_owned());
1480    };
1481    req_builder = req_builder.json(&p_body_public_key_create_input);
1482
1483    let req = req_builder.build()?;
1484    let resp = configuration.client.execute(req).await?;
1485
1486    let status = resp.status();
1487    let content_type = resp
1488        .headers()
1489        .get("content-type")
1490        .and_then(|v| v.to_str().ok())
1491        .unwrap_or("application/octet-stream");
1492    let content_type = super::ContentType::from(content_type);
1493
1494    if !status.is_client_error() && !status.is_server_error() {
1495        let content = resp.text().await?;
1496        match content_type {
1497            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1498            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::PublicKeyModel`"))),
1499            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::PublicKeyModel`")))),
1500        }
1501    } else {
1502        let content = resp.text().await?;
1503        let entity: Option<PostPublicKeyError> = serde_json::from_str(&content).ok();
1504        Err(Error::ResponseError(ResponseContent {
1505            status,
1506            content,
1507            entity,
1508        }))
1509    }
1510}
1511
1512pub async fn post_token(
1513    configuration: &configuration::Configuration,
1514    token_create_input: models::TokenCreateInput,
1515) -> Result<models::TokenCreateOutput, Error<PostTokenError>> {
1516    // add a prefix to parameters to efficiently prevent name collisions
1517    let p_body_token_create_input = token_create_input;
1518
1519    let uri_str = format!("{}/user/tokens", configuration.base_path);
1520    let mut req_builder = configuration
1521        .client
1522        .request(reqwest::Method::POST, &uri_str);
1523
1524    if let Some(ref apikey) = configuration.api_key {
1525        let key = apikey.key.clone();
1526        let value = match apikey.prefix {
1527            Some(ref prefix) => format!("{} {}", prefix, key),
1528            None => key,
1529        };
1530        req_builder = req_builder.query(&[("access_token", value)]);
1531    }
1532    if let Some(ref user_agent) = configuration.user_agent {
1533        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1534    }
1535    if let Some(ref auth_conf) = configuration.basic_auth {
1536        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
1537    };
1538    if let Some(ref token) = configuration.bearer_access_token {
1539        req_builder = req_builder.bearer_auth(token.to_owned());
1540    };
1541    req_builder = req_builder.json(&p_body_token_create_input);
1542
1543    let req = req_builder.build()?;
1544    let resp = configuration.client.execute(req).await?;
1545
1546    let status = resp.status();
1547    let content_type = resp
1548        .headers()
1549        .get("content-type")
1550        .and_then(|v| v.to_str().ok())
1551        .unwrap_or("application/octet-stream");
1552    let content_type = super::ContentType::from(content_type);
1553
1554    if !status.is_client_error() && !status.is_server_error() {
1555        let content = resp.text().await?;
1556        match content_type {
1557            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1558            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TokenCreateOutput`"))),
1559            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TokenCreateOutput`")))),
1560        }
1561    } else {
1562        let content = resp.text().await?;
1563        let entity: Option<PostTokenError> = serde_json::from_str(&content).ok();
1564        Err(Error::ResponseError(ResponseContent {
1565            status,
1566            content,
1567            entity,
1568        }))
1569    }
1570}
1571
1572pub async fn post_two_factor(
1573    configuration: &configuration::Configuration,
1574    two_factor_create_input: models::TwoFactorCreateInput,
1575) -> Result<String, Error<PostTwoFactorError>> {
1576    // add a prefix to parameters to efficiently prevent name collisions
1577    let p_body_two_factor_create_input = two_factor_create_input;
1578
1579    let uri_str = format!("{}/user/security/two_factor", configuration.base_path);
1580    let mut req_builder = configuration
1581        .client
1582        .request(reqwest::Method::POST, &uri_str);
1583
1584    if let Some(ref apikey) = configuration.api_key {
1585        let key = apikey.key.clone();
1586        let value = match apikey.prefix {
1587            Some(ref prefix) => format!("{} {}", prefix, key),
1588            None => key,
1589        };
1590        req_builder = req_builder.query(&[("access_token", value)]);
1591    }
1592    if let Some(ref user_agent) = configuration.user_agent {
1593        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
1594    }
1595    if let Some(ref auth_conf) = configuration.basic_auth {
1596        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
1597    };
1598    if let Some(ref token) = configuration.bearer_access_token {
1599        req_builder = req_builder.bearer_auth(token.to_owned());
1600    };
1601    req_builder = req_builder.json(&p_body_two_factor_create_input);
1602
1603    let req = req_builder.build()?;
1604    let resp = configuration.client.execute(req).await?;
1605
1606    let status = resp.status();
1607    let content_type = resp
1608        .headers()
1609        .get("content-type")
1610        .and_then(|v| v.to_str().ok())
1611        .unwrap_or("application/octet-stream");
1612    let content_type = super::ContentType::from(content_type);
1613
1614    if !status.is_client_error() && !status.is_server_error() {
1615        let content = resp.text().await?;
1616        match content_type {
1617            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
1618            ContentType::Text => Ok(content),
1619            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `String`")))),
1620        }
1621    } else {
1622        let content = resp.text().await?;
1623        let entity: Option<PostTwoFactorError> = serde_json::from_str(&content).ok();
1624        Err(Error::ResponseError(ResponseContent {
1625            status,
1626            content,
1627            entity,
1628        }))
1629    }
1630}
gitbundle_sdk/apis/user_api.rs

gitbundle_sdk/apis/
user_api.rs
