1use reqwest;
13
14use crate::{apis::ResponseContent, models};
15use super::{Error, configuration};
16
17
18#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum TenantsDomainsCreateError {
22 Status400(models::ValidationError),
23 Status403(models::GenericError),
24 UnknownValue(serde_json::Value),
25}
26
27#[derive(Debug, Clone, Serialize, Deserialize)]
29#[serde(untagged)]
30pub enum TenantsDomainsDestroyError {
31 Status400(models::ValidationError),
32 Status403(models::GenericError),
33 UnknownValue(serde_json::Value),
34}
35
36#[derive(Debug, Clone, Serialize, Deserialize)]
38#[serde(untagged)]
39pub enum TenantsDomainsListError {
40 Status400(models::ValidationError),
41 Status403(models::GenericError),
42 UnknownValue(serde_json::Value),
43}
44
45#[derive(Debug, Clone, Serialize, Deserialize)]
47#[serde(untagged)]
48pub enum TenantsDomainsPartialUpdateError {
49 Status400(models::ValidationError),
50 Status403(models::GenericError),
51 UnknownValue(serde_json::Value),
52}
53
54#[derive(Debug, Clone, Serialize, Deserialize)]
56#[serde(untagged)]
57pub enum TenantsDomainsRetrieveError {
58 Status400(models::ValidationError),
59 Status403(models::GenericError),
60 UnknownValue(serde_json::Value),
61}
62
63#[derive(Debug, Clone, Serialize, Deserialize)]
65#[serde(untagged)]
66pub enum TenantsDomainsUpdateError {
67 Status400(models::ValidationError),
68 Status403(models::GenericError),
69 UnknownValue(serde_json::Value),
70}
71
72#[derive(Debug, Clone, Serialize, Deserialize)]
74#[serde(untagged)]
75pub enum TenantsTenantsCreateError {
76 Status400(models::ValidationError),
77 Status403(models::GenericError),
78 UnknownValue(serde_json::Value),
79}
80
81#[derive(Debug, Clone, Serialize, Deserialize)]
83#[serde(untagged)]
84pub enum TenantsTenantsCreateAdminGroupCreateError {
85 Status400(),
86 Status404(),
87 Status403(models::GenericError),
88 UnknownValue(serde_json::Value),
89}
90
91#[derive(Debug, Clone, Serialize, Deserialize)]
93#[serde(untagged)]
94pub enum TenantsTenantsCreateRecoveryKeyCreateError {
95 Status400(),
96 Status404(),
97 Status403(models::GenericError),
98 UnknownValue(serde_json::Value),
99}
100
101#[derive(Debug, Clone, Serialize, Deserialize)]
103#[serde(untagged)]
104pub enum TenantsTenantsDestroyError {
105 Status400(models::ValidationError),
106 Status403(models::GenericError),
107 UnknownValue(serde_json::Value),
108}
109
110#[derive(Debug, Clone, Serialize, Deserialize)]
112#[serde(untagged)]
113pub enum TenantsTenantsListError {
114 Status400(models::ValidationError),
115 Status403(models::GenericError),
116 UnknownValue(serde_json::Value),
117}
118
119#[derive(Debug, Clone, Serialize, Deserialize)]
121#[serde(untagged)]
122pub enum TenantsTenantsPartialUpdateError {
123 Status400(models::ValidationError),
124 Status403(models::GenericError),
125 UnknownValue(serde_json::Value),
126}
127
128#[derive(Debug, Clone, Serialize, Deserialize)]
130#[serde(untagged)]
131pub enum TenantsTenantsRetrieveError {
132 Status400(models::ValidationError),
133 Status403(models::GenericError),
134 UnknownValue(serde_json::Value),
135}
136
137#[derive(Debug, Clone, Serialize, Deserialize)]
139#[serde(untagged)]
140pub enum TenantsTenantsUpdateError {
141 Status400(models::ValidationError),
142 Status403(models::GenericError),
143 UnknownValue(serde_json::Value),
144}
145
146
147pub async fn tenants_domains_create(configuration: &configuration::Configuration, domain_request: models::DomainRequest) -> Result<models::Domain, Error<TenantsDomainsCreateError>> {
149 let local_var_configuration = configuration;
150
151 let local_var_client = &local_var_configuration.client;
152
153 let local_var_uri_str = format!("{}/tenants/domains/", local_var_configuration.base_path);
154 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
155
156 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
157 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
158 }
159 local_var_req_builder = local_var_req_builder.json(&domain_request);
160
161 let local_var_req = local_var_req_builder.build()?;
162 let local_var_resp = local_var_client.execute(local_var_req).await?;
163
164 let local_var_status = local_var_resp.status();
165 let local_var_content = local_var_resp.text().await?;
166
167 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
168 serde_json::from_str(&local_var_content).map_err(Error::from)
169 } else {
170 let local_var_entity: Option<TenantsDomainsCreateError> = serde_json::from_str(&local_var_content).ok();
171 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
172 Err(Error::ResponseError(local_var_error))
173 }
174}
175
176pub async fn tenants_domains_destroy(configuration: &configuration::Configuration, id: i32) -> Result<(), Error<TenantsDomainsDestroyError>> {
178 let local_var_configuration = configuration;
179
180 let local_var_client = &local_var_configuration.client;
181
182 let local_var_uri_str = format!("{}/tenants/domains/{id}/", local_var_configuration.base_path, id=id);
183 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
184
185 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
186 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
187 }
188
189 let local_var_req = local_var_req_builder.build()?;
190 let local_var_resp = local_var_client.execute(local_var_req).await?;
191
192 let local_var_status = local_var_resp.status();
193 let local_var_content = local_var_resp.text().await?;
194
195 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
196 Ok(())
197 } else {
198 let local_var_entity: Option<TenantsDomainsDestroyError> = serde_json::from_str(&local_var_content).ok();
199 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
200 Err(Error::ResponseError(local_var_error))
201 }
202}
203
204pub async fn tenants_domains_list(configuration: &configuration::Configuration, ordering: Option<&str>, page: Option<i32>, page_size: Option<i32>, search: Option<&str>) -> Result<models::PaginatedDomainList, Error<TenantsDomainsListError>> {
206 let local_var_configuration = configuration;
207
208 let local_var_client = &local_var_configuration.client;
209
210 let local_var_uri_str = format!("{}/tenants/domains/", local_var_configuration.base_path);
211 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
212
213 if let Some(ref local_var_str) = ordering {
214 local_var_req_builder = local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
215 }
216 if let Some(ref local_var_str) = page {
217 local_var_req_builder = local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
218 }
219 if let Some(ref local_var_str) = page_size {
220 local_var_req_builder = local_var_req_builder.query(&[("page_size", &local_var_str.to_string())]);
221 }
222 if let Some(ref local_var_str) = search {
223 local_var_req_builder = local_var_req_builder.query(&[("search", &local_var_str.to_string())]);
224 }
225 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
226 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
227 }
228
229 let local_var_req = local_var_req_builder.build()?;
230 let local_var_resp = local_var_client.execute(local_var_req).await?;
231
232 let local_var_status = local_var_resp.status();
233 let local_var_content = local_var_resp.text().await?;
234
235 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
236 serde_json::from_str(&local_var_content).map_err(Error::from)
237 } else {
238 let local_var_entity: Option<TenantsDomainsListError> = serde_json::from_str(&local_var_content).ok();
239 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
240 Err(Error::ResponseError(local_var_error))
241 }
242}
243
244pub async fn tenants_domains_partial_update(configuration: &configuration::Configuration, id: i32, patched_domain_request: Option<models::PatchedDomainRequest>) -> Result<models::Domain, Error<TenantsDomainsPartialUpdateError>> {
246 let local_var_configuration = configuration;
247
248 let local_var_client = &local_var_configuration.client;
249
250 let local_var_uri_str = format!("{}/tenants/domains/{id}/", local_var_configuration.base_path, id=id);
251 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
252
253 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
254 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
255 }
256 local_var_req_builder = local_var_req_builder.json(&patched_domain_request);
257
258 let local_var_req = local_var_req_builder.build()?;
259 let local_var_resp = local_var_client.execute(local_var_req).await?;
260
261 let local_var_status = local_var_resp.status();
262 let local_var_content = local_var_resp.text().await?;
263
264 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
265 serde_json::from_str(&local_var_content).map_err(Error::from)
266 } else {
267 let local_var_entity: Option<TenantsDomainsPartialUpdateError> = serde_json::from_str(&local_var_content).ok();
268 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
269 Err(Error::ResponseError(local_var_error))
270 }
271}
272
273pub async fn tenants_domains_retrieve(configuration: &configuration::Configuration, id: i32) -> Result<models::Domain, Error<TenantsDomainsRetrieveError>> {
275 let local_var_configuration = configuration;
276
277 let local_var_client = &local_var_configuration.client;
278
279 let local_var_uri_str = format!("{}/tenants/domains/{id}/", local_var_configuration.base_path, id=id);
280 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
281
282 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
283 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
284 }
285
286 let local_var_req = local_var_req_builder.build()?;
287 let local_var_resp = local_var_client.execute(local_var_req).await?;
288
289 let local_var_status = local_var_resp.status();
290 let local_var_content = local_var_resp.text().await?;
291
292 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
293 serde_json::from_str(&local_var_content).map_err(Error::from)
294 } else {
295 let local_var_entity: Option<TenantsDomainsRetrieveError> = serde_json::from_str(&local_var_content).ok();
296 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
297 Err(Error::ResponseError(local_var_error))
298 }
299}
300
301pub async fn tenants_domains_update(configuration: &configuration::Configuration, id: i32, domain_request: models::DomainRequest) -> Result<models::Domain, Error<TenantsDomainsUpdateError>> {
303 let local_var_configuration = configuration;
304
305 let local_var_client = &local_var_configuration.client;
306
307 let local_var_uri_str = format!("{}/tenants/domains/{id}/", local_var_configuration.base_path, id=id);
308 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
309
310 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
311 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
312 }
313 local_var_req_builder = local_var_req_builder.json(&domain_request);
314
315 let local_var_req = local_var_req_builder.build()?;
316 let local_var_resp = local_var_client.execute(local_var_req).await?;
317
318 let local_var_status = local_var_resp.status();
319 let local_var_content = local_var_resp.text().await?;
320
321 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
322 serde_json::from_str(&local_var_content).map_err(Error::from)
323 } else {
324 let local_var_entity: Option<TenantsDomainsUpdateError> = serde_json::from_str(&local_var_content).ok();
325 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
326 Err(Error::ResponseError(local_var_error))
327 }
328}
329
330pub async fn tenants_tenants_create(configuration: &configuration::Configuration, tenant_request: models::TenantRequest) -> Result<models::Tenant, Error<TenantsTenantsCreateError>> {
332 let local_var_configuration = configuration;
333
334 let local_var_client = &local_var_configuration.client;
335
336 let local_var_uri_str = format!("{}/tenants/tenants/", local_var_configuration.base_path);
337 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
338
339 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
340 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
341 }
342 local_var_req_builder = local_var_req_builder.json(&tenant_request);
343
344 let local_var_req = local_var_req_builder.build()?;
345 let local_var_resp = local_var_client.execute(local_var_req).await?;
346
347 let local_var_status = local_var_resp.status();
348 let local_var_content = local_var_resp.text().await?;
349
350 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
351 serde_json::from_str(&local_var_content).map_err(Error::from)
352 } else {
353 let local_var_entity: Option<TenantsTenantsCreateError> = serde_json::from_str(&local_var_content).ok();
354 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
355 Err(Error::ResponseError(local_var_error))
356 }
357}
358
359pub async fn tenants_tenants_create_admin_group_create(configuration: &configuration::Configuration, tenant_uuid: &str, tenant_admin_group_request_request: models::TenantAdminGroupRequestRequest) -> Result<(), Error<TenantsTenantsCreateAdminGroupCreateError>> {
361 let local_var_configuration = configuration;
362
363 let local_var_client = &local_var_configuration.client;
364
365 let local_var_uri_str = format!("{}/tenants/tenants/{tenant_uuid}/create_admin_group/", local_var_configuration.base_path, tenant_uuid=crate::apis::urlencode(tenant_uuid));
366 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
367
368 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
369 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
370 }
371 local_var_req_builder = local_var_req_builder.json(&tenant_admin_group_request_request);
372
373 let local_var_req = local_var_req_builder.build()?;
374 let local_var_resp = local_var_client.execute(local_var_req).await?;
375
376 let local_var_status = local_var_resp.status();
377 let local_var_content = local_var_resp.text().await?;
378
379 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
380 Ok(())
381 } else {
382 let local_var_entity: Option<TenantsTenantsCreateAdminGroupCreateError> = serde_json::from_str(&local_var_content).ok();
383 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
384 Err(Error::ResponseError(local_var_error))
385 }
386}
387
388pub async fn tenants_tenants_create_recovery_key_create(configuration: &configuration::Configuration, tenant_uuid: &str, tenant_recovery_key_request_request: models::TenantRecoveryKeyRequestRequest) -> Result<models::TenantRecoveryKeyResponse, Error<TenantsTenantsCreateRecoveryKeyCreateError>> {
390 let local_var_configuration = configuration;
391
392 let local_var_client = &local_var_configuration.client;
393
394 let local_var_uri_str = format!("{}/tenants/tenants/{tenant_uuid}/create_recovery_key/", local_var_configuration.base_path, tenant_uuid=crate::apis::urlencode(tenant_uuid));
395 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
396
397 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
398 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
399 }
400 local_var_req_builder = local_var_req_builder.json(&tenant_recovery_key_request_request);
401
402 let local_var_req = local_var_req_builder.build()?;
403 let local_var_resp = local_var_client.execute(local_var_req).await?;
404
405 let local_var_status = local_var_resp.status();
406 let local_var_content = local_var_resp.text().await?;
407
408 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
409 serde_json::from_str(&local_var_content).map_err(Error::from)
410 } else {
411 let local_var_entity: Option<TenantsTenantsCreateRecoveryKeyCreateError> = serde_json::from_str(&local_var_content).ok();
412 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
413 Err(Error::ResponseError(local_var_error))
414 }
415}
416
417pub async fn tenants_tenants_destroy(configuration: &configuration::Configuration, tenant_uuid: &str) -> Result<(), Error<TenantsTenantsDestroyError>> {
419 let local_var_configuration = configuration;
420
421 let local_var_client = &local_var_configuration.client;
422
423 let local_var_uri_str = format!("{}/tenants/tenants/{tenant_uuid}/", local_var_configuration.base_path, tenant_uuid=crate::apis::urlencode(tenant_uuid));
424 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
425
426 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
427 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
428 }
429
430 let local_var_req = local_var_req_builder.build()?;
431 let local_var_resp = local_var_client.execute(local_var_req).await?;
432
433 let local_var_status = local_var_resp.status();
434 let local_var_content = local_var_resp.text().await?;
435
436 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
437 Ok(())
438 } else {
439 let local_var_entity: Option<TenantsTenantsDestroyError> = serde_json::from_str(&local_var_content).ok();
440 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
441 Err(Error::ResponseError(local_var_error))
442 }
443}
444
445pub async fn tenants_tenants_list(configuration: &configuration::Configuration, ordering: Option<&str>, page: Option<i32>, page_size: Option<i32>, search: Option<&str>) -> Result<models::PaginatedTenantList, Error<TenantsTenantsListError>> {
447 let local_var_configuration = configuration;
448
449 let local_var_client = &local_var_configuration.client;
450
451 let local_var_uri_str = format!("{}/tenants/tenants/", local_var_configuration.base_path);
452 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
453
454 if let Some(ref local_var_str) = ordering {
455 local_var_req_builder = local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
456 }
457 if let Some(ref local_var_str) = page {
458 local_var_req_builder = local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
459 }
460 if let Some(ref local_var_str) = page_size {
461 local_var_req_builder = local_var_req_builder.query(&[("page_size", &local_var_str.to_string())]);
462 }
463 if let Some(ref local_var_str) = search {
464 local_var_req_builder = local_var_req_builder.query(&[("search", &local_var_str.to_string())]);
465 }
466 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
467 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
468 }
469
470 let local_var_req = local_var_req_builder.build()?;
471 let local_var_resp = local_var_client.execute(local_var_req).await?;
472
473 let local_var_status = local_var_resp.status();
474 let local_var_content = local_var_resp.text().await?;
475
476 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
477 serde_json::from_str(&local_var_content).map_err(Error::from)
478 } else {
479 let local_var_entity: Option<TenantsTenantsListError> = serde_json::from_str(&local_var_content).ok();
480 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
481 Err(Error::ResponseError(local_var_error))
482 }
483}
484
485pub async fn tenants_tenants_partial_update(configuration: &configuration::Configuration, tenant_uuid: &str, patched_tenant_request: Option<models::PatchedTenantRequest>) -> Result<models::Tenant, Error<TenantsTenantsPartialUpdateError>> {
487 let local_var_configuration = configuration;
488
489 let local_var_client = &local_var_configuration.client;
490
491 let local_var_uri_str = format!("{}/tenants/tenants/{tenant_uuid}/", local_var_configuration.base_path, tenant_uuid=crate::apis::urlencode(tenant_uuid));
492 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
493
494 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
495 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
496 }
497 local_var_req_builder = local_var_req_builder.json(&patched_tenant_request);
498
499 let local_var_req = local_var_req_builder.build()?;
500 let local_var_resp = local_var_client.execute(local_var_req).await?;
501
502 let local_var_status = local_var_resp.status();
503 let local_var_content = local_var_resp.text().await?;
504
505 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
506 serde_json::from_str(&local_var_content).map_err(Error::from)
507 } else {
508 let local_var_entity: Option<TenantsTenantsPartialUpdateError> = serde_json::from_str(&local_var_content).ok();
509 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
510 Err(Error::ResponseError(local_var_error))
511 }
512}
513
514pub async fn tenants_tenants_retrieve(configuration: &configuration::Configuration, tenant_uuid: &str) -> Result<models::Tenant, Error<TenantsTenantsRetrieveError>> {
516 let local_var_configuration = configuration;
517
518 let local_var_client = &local_var_configuration.client;
519
520 let local_var_uri_str = format!("{}/tenants/tenants/{tenant_uuid}/", local_var_configuration.base_path, tenant_uuid=crate::apis::urlencode(tenant_uuid));
521 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
522
523 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
524 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
525 }
526
527 let local_var_req = local_var_req_builder.build()?;
528 let local_var_resp = local_var_client.execute(local_var_req).await?;
529
530 let local_var_status = local_var_resp.status();
531 let local_var_content = local_var_resp.text().await?;
532
533 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
534 serde_json::from_str(&local_var_content).map_err(Error::from)
535 } else {
536 let local_var_entity: Option<TenantsTenantsRetrieveError> = serde_json::from_str(&local_var_content).ok();
537 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
538 Err(Error::ResponseError(local_var_error))
539 }
540}
541
542pub async fn tenants_tenants_update(configuration: &configuration::Configuration, tenant_uuid: &str, tenant_request: models::TenantRequest) -> Result<models::Tenant, Error<TenantsTenantsUpdateError>> {
544 let local_var_configuration = configuration;
545
546 let local_var_client = &local_var_configuration.client;
547
548 let local_var_uri_str = format!("{}/tenants/tenants/{tenant_uuid}/", local_var_configuration.base_path, tenant_uuid=crate::apis::urlencode(tenant_uuid));
549 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
550
551 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
552 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
553 }
554 local_var_req_builder = local_var_req_builder.json(&tenant_request);
555
556 let local_var_req = local_var_req_builder.build()?;
557 let local_var_resp = local_var_client.execute(local_var_req).await?;
558
559 let local_var_status = local_var_resp.status();
560 let local_var_content = local_var_resp.text().await?;
561
562 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
563 serde_json::from_str(&local_var_content).map_err(Error::from)
564 } else {
565 let local_var_entity: Option<TenantsTenantsUpdateError> = serde_json::from_str(&local_var_content).ok();
566 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
567 Err(Error::ResponseError(local_var_error))
568 }
569}
570