1use reqwest;
12
13use super::Error;
14use crate::{apis::ResponseContent, clerk::Clerk};
15
16#[derive(Debug, Clone, Serialize, Deserialize)]
18#[serde(untagged)]
19pub enum CreateAllowlistIdentifierError {
20 Status400(crate::models::ClerkErrors),
21 Status402(crate::models::ClerkErrors),
22 Status422(crate::models::ClerkErrors),
23 UnknownValue(serde_json::Value),
24}
25
26#[derive(Debug, Clone, Serialize, Deserialize)]
28#[serde(untagged)]
29pub enum CreateBlocklistIdentifierError {
30 Status400(crate::models::ClerkErrors),
31 Status402(crate::models::ClerkErrors),
32 Status422(crate::models::ClerkErrors),
33 UnknownValue(serde_json::Value),
34}
35
36#[derive(Debug, Clone, Serialize, Deserialize)]
38#[serde(untagged)]
39pub enum DeleteAllowlistIdentifierError {
40 Status402(crate::models::ClerkErrors),
41 Status404(crate::models::ClerkErrors),
42 UnknownValue(serde_json::Value),
43}
44
45#[derive(Debug, Clone, Serialize, Deserialize)]
47#[serde(untagged)]
48pub enum DeleteBlocklistIdentifierError {
49 Status402(crate::models::ClerkErrors),
50 Status404(crate::models::ClerkErrors),
51 UnknownValue(serde_json::Value),
52}
53
54#[derive(Debug, Clone, Serialize, Deserialize)]
56#[serde(untagged)]
57pub enum ListAllowlistIdentifiersError {
58 Status401(crate::models::ClerkErrors),
59 Status402(crate::models::ClerkErrors),
60 UnknownValue(serde_json::Value),
61}
62
63#[derive(Debug, Clone, Serialize, Deserialize)]
65#[serde(untagged)]
66pub enum ListBlocklistIdentifiersError {
67 Status401(crate::models::ClerkErrors),
68 Status402(crate::models::ClerkErrors),
69 UnknownValue(serde_json::Value),
70}
71
72pub struct ListIdentifier;
73
74impl ListIdentifier {
75 pub async fn create_allowlist_identifier(
77 clerk_client: &Clerk,
78 ) -> Result<crate::models::AllowlistIdentifier, Error<CreateAllowlistIdentifierError>> {
79 let local_var_configuration = &clerk_client.config;
80
81 let local_var_client = &local_var_configuration.client;
82
83 let local_var_uri_str = format!("{}/allowlist_identifiers", local_var_configuration.base_path);
84 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
85
86 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
87 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
88 }
89
90 let local_var_req = local_var_req_builder.build()?;
91 let local_var_resp = local_var_client.execute(local_var_req).await?;
92
93 let local_var_status = local_var_resp.status();
94 let local_var_content = local_var_resp.text().await?;
95
96 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
97 serde_json::from_str(&local_var_content).map_err(Error::from)
98 } else {
99 let local_var_entity: Option<CreateAllowlistIdentifierError> = serde_json::from_str(&local_var_content).ok();
100 let local_var_error = ResponseContent {
101 status: local_var_status,
102 content: local_var_content,
103 entity: local_var_entity,
104 };
105 Err(Error::ResponseError(local_var_error))
106 }
107 }
108
109 pub async fn create_blocklist_identifier(
111 clerk_client: &Clerk,
112 ) -> Result<crate::models::BlocklistIdentifier, Error<CreateBlocklistIdentifierError>> {
113 let local_var_configuration = &clerk_client.config;
114
115 let local_var_client = &local_var_configuration.client;
116
117 let local_var_uri_str = format!("{}/blocklist_identifiers", local_var_configuration.base_path);
118 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
119
120 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
121 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
122 }
123
124 let local_var_req = local_var_req_builder.build()?;
125 let local_var_resp = local_var_client.execute(local_var_req).await?;
126
127 let local_var_status = local_var_resp.status();
128 let local_var_content = local_var_resp.text().await?;
129
130 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
131 serde_json::from_str(&local_var_content).map_err(Error::from)
132 } else {
133 let local_var_entity: Option<CreateBlocklistIdentifierError> = serde_json::from_str(&local_var_content).ok();
134 let local_var_error = ResponseContent {
135 status: local_var_status,
136 content: local_var_content,
137 entity: local_var_entity,
138 };
139 Err(Error::ResponseError(local_var_error))
140 }
141 }
142
143 pub async fn delete_allowlist_identifier(
145 clerk_client: &Clerk,
146 identifier_id: &str,
147 ) -> Result<crate::models::DeletedObject, Error<DeleteAllowlistIdentifierError>> {
148 let local_var_configuration = &clerk_client.config;
149
150 let local_var_client = &local_var_configuration.client;
151
152 let local_var_uri_str = format!(
153 "{}/allowlist_identifiers/{identifier_id}",
154 local_var_configuration.base_path,
155 identifier_id = crate::apis::urlencode(identifier_id)
156 );
157 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
158
159 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
160 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
161 }
162
163 let local_var_req = local_var_req_builder.build()?;
164 let local_var_resp = local_var_client.execute(local_var_req).await?;
165
166 let local_var_status = local_var_resp.status();
167 let local_var_content = local_var_resp.text().await?;
168
169 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
170 serde_json::from_str(&local_var_content).map_err(Error::from)
171 } else {
172 let local_var_entity: Option<DeleteAllowlistIdentifierError> = serde_json::from_str(&local_var_content).ok();
173 let local_var_error = ResponseContent {
174 status: local_var_status,
175 content: local_var_content,
176 entity: local_var_entity,
177 };
178 Err(Error::ResponseError(local_var_error))
179 }
180 }
181
182 pub async fn delete_blocklist_identifier(
184 clerk_client: &Clerk,
185 identifier_id: &str,
186 ) -> Result<crate::models::DeletedObject, Error<DeleteBlocklistIdentifierError>> {
187 let local_var_configuration = &clerk_client.config;
188
189 let local_var_client = &local_var_configuration.client;
190
191 let local_var_uri_str = format!(
192 "{}/blocklist_identifiers/{identifier_id}",
193 local_var_configuration.base_path,
194 identifier_id = crate::apis::urlencode(identifier_id)
195 );
196 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
197
198 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
199 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
200 }
201
202 let local_var_req = local_var_req_builder.build()?;
203 let local_var_resp = local_var_client.execute(local_var_req).await?;
204
205 let local_var_status = local_var_resp.status();
206 let local_var_content = local_var_resp.text().await?;
207
208 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
209 serde_json::from_str(&local_var_content).map_err(Error::from)
210 } else {
211 let local_var_entity: Option<DeleteBlocklistIdentifierError> = serde_json::from_str(&local_var_content).ok();
212 let local_var_error = ResponseContent {
213 status: local_var_status,
214 content: local_var_content,
215 entity: local_var_entity,
216 };
217 Err(Error::ResponseError(local_var_error))
218 }
219 }
220
221 pub async fn list_allowlist_identifiers(
223 clerk_client: &Clerk,
224 ) -> Result<Vec<crate::models::AllowlistIdentifier>, Error<ListAllowlistIdentifiersError>> {
225 let local_var_configuration = &clerk_client.config;
226
227 let local_var_client = &local_var_configuration.client;
228
229 let local_var_uri_str = format!("{}/allowlist_identifiers", local_var_configuration.base_path);
230 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
231
232 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
233 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
234 }
235
236 let local_var_req = local_var_req_builder.build()?;
237 let local_var_resp = local_var_client.execute(local_var_req).await?;
238
239 let local_var_status = local_var_resp.status();
240 let local_var_content = local_var_resp.text().await?;
241
242 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
243 serde_json::from_str(&local_var_content).map_err(Error::from)
244 } else {
245 let local_var_entity: Option<ListAllowlistIdentifiersError> = serde_json::from_str(&local_var_content).ok();
246 let local_var_error = ResponseContent {
247 status: local_var_status,
248 content: local_var_content,
249 entity: local_var_entity,
250 };
251 Err(Error::ResponseError(local_var_error))
252 }
253 }
254
255 pub async fn list_blocklist_identifiers(
257 clerk_client: &Clerk,
258 ) -> Result<crate::models::BlocklistIdentifiers, Error<ListBlocklistIdentifiersError>> {
259 let local_var_configuration = &clerk_client.config;
260
261 let local_var_client = &local_var_configuration.client;
262
263 let local_var_uri_str = format!("{}/blocklist_identifiers", local_var_configuration.base_path);
264 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
265
266 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
267 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
268 }
269
270 let local_var_req = local_var_req_builder.build()?;
271 let local_var_resp = local_var_client.execute(local_var_req).await?;
272
273 let local_var_status = local_var_resp.status();
274 let local_var_content = local_var_resp.text().await?;
275
276 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
277 serde_json::from_str(&local_var_content).map_err(Error::from)
278 } else {
279 let local_var_entity: Option<ListBlocklistIdentifiersError> = serde_json::from_str(&local_var_content).ok();
280 let local_var_error = ResponseContent {
281 status: local_var_status,
282 content: local_var_content,
283 entity: local_var_entity,
284 };
285 Err(Error::ResponseError(local_var_error))
286 }
287 }
288}