1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use crate::model::*;
use crate::JyveClient;
use serde_json::json;
/**Create this with the associated client method.

That method takes required values as arguments. Set optional values using builder methods on this struct.*/
#[derive(Clone)]
pub struct StoreGroupsListRequest<'a> {
    pub(crate) http_client: &'a JyveClient,
    pub ancestor: Option<String>,
    pub id: Option<f64>,
    pub ids: Option<String>,
    pub is_archived: Option<String>,
    pub name: Option<String>,
    pub ordering: Option<String>,
    pub page: Option<i64>,
    pub page_size: Option<i64>,
    pub parent: Option<f64>,
    pub primary_manager: Option<f64>,
    pub slug: Option<String>,
    pub source: Option<String>,
    pub type_: Option<String>,
}
impl<'a> StoreGroupsListRequest<'a> {
    pub async fn send(self) -> ::httpclient::InMemoryResult<Vec<StoreGroupWithChildren>> {
        let mut r = self.http_client.client.get("/store_groups/");
        if let Some(ref unwrapped) = self.ancestor {
            r = r.query("ancestor", &unwrapped.to_string());
        }
        if let Some(ref unwrapped) = self.id {
            r = r.query("id", &unwrapped.to_string());
        }
        if let Some(ref unwrapped) = self.ids {
            r = r.query("ids", &unwrapped.to_string());
        }
        if let Some(ref unwrapped) = self.is_archived {
            r = r.query("is_archived", &unwrapped.to_string());
        }
        if let Some(ref unwrapped) = self.name {
            r = r.query("name", &unwrapped.to_string());
        }
        if let Some(ref unwrapped) = self.ordering {
            r = r.query("ordering", &unwrapped.to_string());
        }
        if let Some(ref unwrapped) = self.page {
            r = r.query("page", &unwrapped.to_string());
        }
        if let Some(ref unwrapped) = self.page_size {
            r = r.query("page_size", &unwrapped.to_string());
        }
        if let Some(ref unwrapped) = self.parent {
            r = r.query("parent", &unwrapped.to_string());
        }
        if let Some(ref unwrapped) = self.primary_manager {
            r = r.query("primary_manager", &unwrapped.to_string());
        }
        if let Some(ref unwrapped) = self.slug {
            r = r.query("slug", &unwrapped.to_string());
        }
        if let Some(ref unwrapped) = self.source {
            r = r.query("source", &unwrapped.to_string());
        }
        if let Some(ref unwrapped) = self.type_ {
            r = r.query("type", &unwrapped.to_string());
        }
        r = self.http_client.authenticate(r);
        let res = r.send_awaiting_body().await?;
        res.json()
    }
    pub fn ancestor(mut self, ancestor: &str) -> Self {
        self.ancestor = Some(ancestor.to_owned());
        self
    }
    pub fn id(mut self, id: f64) -> Self {
        self.id = Some(id);
        self
    }
    pub fn ids(mut self, ids: &str) -> Self {
        self.ids = Some(ids.to_owned());
        self
    }
    pub fn is_archived(mut self, is_archived: &str) -> Self {
        self.is_archived = Some(is_archived.to_owned());
        self
    }
    pub fn name(mut self, name: &str) -> Self {
        self.name = Some(name.to_owned());
        self
    }
    pub fn ordering(mut self, ordering: &str) -> Self {
        self.ordering = Some(ordering.to_owned());
        self
    }
    pub fn page(mut self, page: i64) -> Self {
        self.page = Some(page);
        self
    }
    pub fn page_size(mut self, page_size: i64) -> Self {
        self.page_size = Some(page_size);
        self
    }
    pub fn parent(mut self, parent: f64) -> Self {
        self.parent = Some(parent);
        self
    }
    pub fn primary_manager(mut self, primary_manager: f64) -> Self {
        self.primary_manager = Some(primary_manager);
        self
    }
    pub fn slug(mut self, slug: &str) -> Self {
        self.slug = Some(slug.to_owned());
        self
    }
    pub fn source(mut self, source: &str) -> Self {
        self.source = Some(source.to_owned());
        self
    }
    pub fn type_(mut self, type_: &str) -> Self {
        self.type_ = Some(type_.to_owned());
        self
    }
}
impl<'a> ::std::future::IntoFuture for StoreGroupsListRequest<'a> {
    type Output = httpclient::InMemoryResult<Vec<StoreGroupWithChildren>>;
    type IntoFuture = ::futures::future::BoxFuture<'a, Self::Output>;
    fn into_future(self) -> Self::IntoFuture {
        Box::pin(self.send())
    }
}