photon_api/apis/
default_api.rs

1/*
2 * photon-indexer
3 *
4 * Solana indexer for general compression
5 *
6 * The version of the OpenAPI document: 0.50.0
7 *
8 * Generated by: https://openapi-generator.tech
9 */
10
11use reqwest;
12
13use super::{configuration, Error};
14use crate::{
15    apis::{configuration::Configuration, ResponseContent},
16    models,
17};
18
19/// struct for typed errors of method [`get_batch_address_update_info_post`]
20#[derive(Debug, Clone, Serialize, Deserialize)]
21#[serde(untagged)]
22pub enum GetBatchAddressUpdateInfoPostError {
23    Status429(models::GetBatchAddressUpdateInfoPost429Response),
24    Status500(models::GetBatchAddressUpdateInfoPost429Response),
25    UnknownValue(serde_json::Value),
26}
27
28/// struct for typed errors of method [`get_compressed_account_balance_post`]
29#[derive(Debug, Clone, Serialize, Deserialize)]
30#[serde(untagged)]
31pub enum GetCompressedAccountBalancePostError {
32    Status429(models::GetBatchAddressUpdateInfoPost429Response),
33    Status500(models::GetBatchAddressUpdateInfoPost429Response),
34    UnknownValue(serde_json::Value),
35}
36
37/// struct for typed errors of method [`get_compressed_account_post`]
38#[derive(Debug, Clone, Serialize, Deserialize)]
39#[serde(untagged)]
40pub enum GetCompressedAccountPostError {
41    Status429(models::GetBatchAddressUpdateInfoPost429Response),
42    Status500(models::GetBatchAddressUpdateInfoPost429Response),
43    UnknownValue(serde_json::Value),
44}
45
46/// struct for typed errors of method [`get_compressed_account_proof_post`]
47#[derive(Debug, Clone, Serialize, Deserialize)]
48#[serde(untagged)]
49pub enum GetCompressedAccountProofPostError {
50    Status429(models::GetBatchAddressUpdateInfoPost429Response),
51    Status500(models::GetBatchAddressUpdateInfoPost429Response),
52    UnknownValue(serde_json::Value),
53}
54
55/// struct for typed errors of method [`get_compressed_account_proof_v2_post`]
56#[derive(Debug, Clone, Serialize, Deserialize)]
57#[serde(untagged)]
58pub enum GetCompressedAccountProofV2PostError {
59    Status429(models::GetBatchAddressUpdateInfoPost429Response),
60    Status500(models::GetBatchAddressUpdateInfoPost429Response),
61    UnknownValue(serde_json::Value),
62}
63
64/// struct for typed errors of method [`get_compressed_account_v2_post`]
65#[derive(Debug, Clone, Serialize, Deserialize)]
66#[serde(untagged)]
67pub enum GetCompressedAccountV2PostError {
68    Status429(models::GetBatchAddressUpdateInfoPost429Response),
69    Status500(models::GetBatchAddressUpdateInfoPost429Response),
70    UnknownValue(serde_json::Value),
71}
72
73/// struct for typed errors of method [`get_compressed_accounts_by_owner_post`]
74#[derive(Debug, Clone, Serialize, Deserialize)]
75#[serde(untagged)]
76pub enum GetCompressedAccountsByOwnerPostError {
77    Status429(models::GetBatchAddressUpdateInfoPost429Response),
78    Status500(models::GetBatchAddressUpdateInfoPost429Response),
79    UnknownValue(serde_json::Value),
80}
81
82/// struct for typed errors of method [`get_compressed_accounts_by_owner_v2_post`]
83#[derive(Debug, Clone, Serialize, Deserialize)]
84#[serde(untagged)]
85pub enum GetCompressedAccountsByOwnerV2PostError {
86    Status429(models::GetBatchAddressUpdateInfoPost429Response),
87    Status500(models::GetBatchAddressUpdateInfoPost429Response),
88    UnknownValue(serde_json::Value),
89}
90
91/// struct for typed errors of method [`get_compressed_balance_by_owner_post`]
92#[derive(Debug, Clone, Serialize, Deserialize)]
93#[serde(untagged)]
94pub enum GetCompressedBalanceByOwnerPostError {
95    Status429(models::GetBatchAddressUpdateInfoPost429Response),
96    Status500(models::GetBatchAddressUpdateInfoPost429Response),
97    UnknownValue(serde_json::Value),
98}
99
100/// struct for typed errors of method [`get_compressed_mint_token_holders_post`]
101#[derive(Debug, Clone, Serialize, Deserialize)]
102#[serde(untagged)]
103pub enum GetCompressedMintTokenHoldersPostError {
104    Status429(models::GetBatchAddressUpdateInfoPost429Response),
105    Status500(models::GetBatchAddressUpdateInfoPost429Response),
106    UnknownValue(serde_json::Value),
107}
108
109/// struct for typed errors of method [`get_compressed_token_account_balance_post`]
110#[derive(Debug, Clone, Serialize, Deserialize)]
111#[serde(untagged)]
112pub enum GetCompressedTokenAccountBalancePostError {
113    Status429(models::GetBatchAddressUpdateInfoPost429Response),
114    Status500(models::GetBatchAddressUpdateInfoPost429Response),
115    UnknownValue(serde_json::Value),
116}
117
118/// struct for typed errors of method [`get_compressed_token_accounts_by_delegate_post`]
119#[derive(Debug, Clone, Serialize, Deserialize)]
120#[serde(untagged)]
121pub enum GetCompressedTokenAccountsByDelegatePostError {
122    Status429(models::GetBatchAddressUpdateInfoPost429Response),
123    Status500(models::GetBatchAddressUpdateInfoPost429Response),
124    UnknownValue(serde_json::Value),
125}
126
127/// struct for typed errors of method [`get_compressed_token_accounts_by_delegate_v2_post`]
128#[derive(Debug, Clone, Serialize, Deserialize)]
129#[serde(untagged)]
130pub enum GetCompressedTokenAccountsByDelegateV2PostError {
131    Status429(models::GetBatchAddressUpdateInfoPost429Response),
132    Status500(models::GetBatchAddressUpdateInfoPost429Response),
133    UnknownValue(serde_json::Value),
134}
135
136/// struct for typed errors of method [`get_compressed_token_accounts_by_owner_post`]
137#[derive(Debug, Clone, Serialize, Deserialize)]
138#[serde(untagged)]
139pub enum GetCompressedTokenAccountsByOwnerPostError {
140    Status429(models::GetBatchAddressUpdateInfoPost429Response),
141    Status500(models::GetBatchAddressUpdateInfoPost429Response),
142    UnknownValue(serde_json::Value),
143}
144
145/// struct for typed errors of method [`get_compressed_token_accounts_by_owner_v2_post`]
146#[derive(Debug, Clone, Serialize, Deserialize)]
147#[serde(untagged)]
148pub enum GetCompressedTokenAccountsByOwnerV2PostError {
149    Status429(models::GetBatchAddressUpdateInfoPost429Response),
150    Status500(models::GetBatchAddressUpdateInfoPost429Response),
151    UnknownValue(serde_json::Value),
152}
153
154/// struct for typed errors of method [`get_compressed_token_balances_by_owner_post`]
155#[derive(Debug, Clone, Serialize, Deserialize)]
156#[serde(untagged)]
157pub enum GetCompressedTokenBalancesByOwnerPostError {
158    Status429(models::GetBatchAddressUpdateInfoPost429Response),
159    Status500(models::GetBatchAddressUpdateInfoPost429Response),
160    UnknownValue(serde_json::Value),
161}
162
163/// struct for typed errors of method [`get_compressed_token_balances_by_owner_v2_post`]
164#[derive(Debug, Clone, Serialize, Deserialize)]
165#[serde(untagged)]
166pub enum GetCompressedTokenBalancesByOwnerV2PostError {
167    Status429(models::GetBatchAddressUpdateInfoPost429Response),
168    Status500(models::GetBatchAddressUpdateInfoPost429Response),
169    UnknownValue(serde_json::Value),
170}
171
172/// struct for typed errors of method [`get_compression_signatures_for_account_post`]
173#[derive(Debug, Clone, Serialize, Deserialize)]
174#[serde(untagged)]
175pub enum GetCompressionSignaturesForAccountPostError {
176    Status429(models::GetBatchAddressUpdateInfoPost429Response),
177    Status500(models::GetBatchAddressUpdateInfoPost429Response),
178    UnknownValue(serde_json::Value),
179}
180
181/// struct for typed errors of method [`get_compression_signatures_for_address_post`]
182#[derive(Debug, Clone, Serialize, Deserialize)]
183#[serde(untagged)]
184pub enum GetCompressionSignaturesForAddressPostError {
185    Status429(models::GetBatchAddressUpdateInfoPost429Response),
186    Status500(models::GetBatchAddressUpdateInfoPost429Response),
187    UnknownValue(serde_json::Value),
188}
189
190/// struct for typed errors of method [`get_compression_signatures_for_owner_post`]
191#[derive(Debug, Clone, Serialize, Deserialize)]
192#[serde(untagged)]
193pub enum GetCompressionSignaturesForOwnerPostError {
194    Status429(models::GetBatchAddressUpdateInfoPost429Response),
195    Status500(models::GetBatchAddressUpdateInfoPost429Response),
196    UnknownValue(serde_json::Value),
197}
198
199/// struct for typed errors of method [`get_compression_signatures_for_token_owner_post`]
200#[derive(Debug, Clone, Serialize, Deserialize)]
201#[serde(untagged)]
202pub enum GetCompressionSignaturesForTokenOwnerPostError {
203    Status429(models::GetBatchAddressUpdateInfoPost429Response),
204    Status500(models::GetBatchAddressUpdateInfoPost429Response),
205    UnknownValue(serde_json::Value),
206}
207
208/// struct for typed errors of method [`get_indexer_health_post`]
209#[derive(Debug, Clone, Serialize, Deserialize)]
210#[serde(untagged)]
211pub enum GetIndexerHealthPostError {
212    Status429(models::GetBatchAddressUpdateInfoPost429Response),
213    Status500(models::GetBatchAddressUpdateInfoPost429Response),
214    UnknownValue(serde_json::Value),
215}
216
217/// struct for typed errors of method [`get_indexer_slot_post`]
218#[derive(Debug, Clone, Serialize, Deserialize)]
219#[serde(untagged)]
220pub enum GetIndexerSlotPostError {
221    Status429(models::GetBatchAddressUpdateInfoPost429Response),
222    Status500(models::GetBatchAddressUpdateInfoPost429Response),
223    UnknownValue(serde_json::Value),
224}
225
226/// struct for typed errors of method [`get_latest_compression_signatures_post`]
227#[derive(Debug, Clone, Serialize, Deserialize)]
228#[serde(untagged)]
229pub enum GetLatestCompressionSignaturesPostError {
230    Status429(models::GetBatchAddressUpdateInfoPost429Response),
231    Status500(models::GetBatchAddressUpdateInfoPost429Response),
232    UnknownValue(serde_json::Value),
233}
234
235/// struct for typed errors of method [`get_latest_non_voting_signatures_post`]
236#[derive(Debug, Clone, Serialize, Deserialize)]
237#[serde(untagged)]
238pub enum GetLatestNonVotingSignaturesPostError {
239    Status429(models::GetBatchAddressUpdateInfoPost429Response),
240    Status500(models::GetBatchAddressUpdateInfoPost429Response),
241    UnknownValue(serde_json::Value),
242}
243
244/// struct for typed errors of method [`get_multiple_compressed_account_proofs_post`]
245#[derive(Debug, Clone, Serialize, Deserialize)]
246#[serde(untagged)]
247pub enum GetMultipleCompressedAccountProofsPostError {
248    Status429(models::GetBatchAddressUpdateInfoPost429Response),
249    Status500(models::GetBatchAddressUpdateInfoPost429Response),
250    UnknownValue(serde_json::Value),
251}
252
253/// struct for typed errors of method [`get_multiple_compressed_account_proofs_v2_post`]
254#[derive(Debug, Clone, Serialize, Deserialize)]
255#[serde(untagged)]
256pub enum GetMultipleCompressedAccountProofsV2PostError {
257    Status429(models::GetBatchAddressUpdateInfoPost429Response),
258    Status500(models::GetBatchAddressUpdateInfoPost429Response),
259    UnknownValue(serde_json::Value),
260}
261
262/// struct for typed errors of method [`get_multiple_compressed_accounts_post`]
263#[derive(Debug, Clone, Serialize, Deserialize)]
264#[serde(untagged)]
265pub enum GetMultipleCompressedAccountsPostError {
266    Status429(models::GetBatchAddressUpdateInfoPost429Response),
267    Status500(models::GetBatchAddressUpdateInfoPost429Response),
268    UnknownValue(serde_json::Value),
269}
270
271/// struct for typed errors of method [`get_multiple_compressed_accounts_v2_post`]
272#[derive(Debug, Clone, Serialize, Deserialize)]
273#[serde(untagged)]
274pub enum GetMultipleCompressedAccountsV2PostError {
275    Status429(models::GetBatchAddressUpdateInfoPost429Response),
276    Status500(models::GetBatchAddressUpdateInfoPost429Response),
277    UnknownValue(serde_json::Value),
278}
279
280/// struct for typed errors of method [`get_multiple_new_address_proofs_post`]
281#[derive(Debug, Clone, Serialize, Deserialize)]
282#[serde(untagged)]
283pub enum GetMultipleNewAddressProofsPostError {
284    Status429(models::GetBatchAddressUpdateInfoPost429Response),
285    Status500(models::GetBatchAddressUpdateInfoPost429Response),
286    UnknownValue(serde_json::Value),
287}
288
289/// struct for typed errors of method [`get_multiple_new_address_proofs_v2_post`]
290#[derive(Debug, Clone, Serialize, Deserialize)]
291#[serde(untagged)]
292pub enum GetMultipleNewAddressProofsV2PostError {
293    Status429(models::GetBatchAddressUpdateInfoPost429Response),
294    Status500(models::GetBatchAddressUpdateInfoPost429Response),
295    UnknownValue(serde_json::Value),
296}
297
298/// struct for typed errors of method [`get_queue_elements_post`]
299#[derive(Debug, Clone, Serialize, Deserialize)]
300#[serde(untagged)]
301pub enum GetQueueElementsPostError {
302    Status429(models::GetBatchAddressUpdateInfoPost429Response),
303    Status500(models::GetBatchAddressUpdateInfoPost429Response),
304    UnknownValue(serde_json::Value),
305}
306
307/// struct for typed errors of method [`get_transaction_with_compression_info_post`]
308#[derive(Debug, Clone, Serialize, Deserialize)]
309#[serde(untagged)]
310pub enum GetTransactionWithCompressionInfoPostError {
311    Status429(models::GetBatchAddressUpdateInfoPost429Response),
312    Status500(models::GetBatchAddressUpdateInfoPost429Response),
313    UnknownValue(serde_json::Value),
314}
315
316/// struct for typed errors of method [`get_transaction_with_compression_info_v2_post`]
317#[derive(Debug, Clone, Serialize, Deserialize)]
318#[serde(untagged)]
319pub enum GetTransactionWithCompressionInfoV2PostError {
320    Status429(models::GetBatchAddressUpdateInfoPost429Response),
321    Status500(models::GetBatchAddressUpdateInfoPost429Response),
322    UnknownValue(serde_json::Value),
323}
324
325/// struct for typed errors of method [`get_validity_proof_post`]
326#[derive(Debug, Clone, Serialize, Deserialize)]
327#[serde(untagged)]
328pub enum GetValidityProofPostError {
329    Status429(models::GetBatchAddressUpdateInfoPost429Response),
330    Status500(models::GetBatchAddressUpdateInfoPost429Response),
331    UnknownValue(serde_json::Value),
332}
333
334/// struct for typed errors of method [`get_validity_proof_v2_post`]
335#[derive(Debug, Clone, Serialize, Deserialize)]
336#[serde(untagged)]
337pub enum GetValidityProofV2PostError {
338    Status429(models::GetBatchAddressUpdateInfoPost429Response),
339    Status500(models::GetBatchAddressUpdateInfoPost429Response),
340    UnknownValue(serde_json::Value),
341}
342
343pub async fn get_batch_address_update_info_post(
344    configuration: &configuration::Configuration,
345    get_batch_address_update_info_post_request: models::GetBatchAddressUpdateInfoPostRequest,
346) -> Result<
347    models::GetBatchAddressUpdateInfoPost200Response,
348    Error<GetBatchAddressUpdateInfoPostError>,
349> {
350    let local_var_configuration = configuration;
351
352    let local_var_client = &local_var_configuration.client;
353
354    let local_var_uri_str = format!(
355        "{}/getBatchAddressUpdateInfo",
356        local_var_configuration.base_path
357    );
358    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
359    let mut local_var_req_builder =
360        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
361
362    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
363        local_var_req_builder =
364            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
365    }
366    local_var_req_builder = local_var_req_builder.json(&get_batch_address_update_info_post_request);
367
368    let local_var_req = local_var_req_builder.build()?;
369    let local_var_resp = local_var_client.execute(local_var_req).await?;
370
371    let local_var_status = local_var_resp.status();
372    let local_var_content = local_var_resp.text().await?;
373
374    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
375        serde_json::from_str(&local_var_content).map_err(Error::from)
376    } else {
377        let local_var_entity: Option<GetBatchAddressUpdateInfoPostError> =
378            serde_json::from_str(&local_var_content).ok();
379        let local_var_error = ResponseContent {
380            status: local_var_status,
381            content: local_var_content,
382            entity: local_var_entity,
383        };
384        Err(Error::ResponseError(local_var_error))
385    }
386}
387
388pub async fn get_compressed_account_balance_post(
389    configuration: &configuration::Configuration,
390    get_compressed_account_balance_post_request: models::GetCompressedAccountBalancePostRequest,
391) -> Result<
392    models::GetCompressedAccountBalancePost200Response,
393    Error<GetCompressedAccountBalancePostError>,
394> {
395    let local_var_configuration = configuration;
396
397    let local_var_client = &local_var_configuration.client;
398
399    let local_var_uri_str = format!(
400        "{}/getCompressedAccountBalance",
401        local_var_configuration.base_path
402    );
403    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
404    let mut local_var_req_builder =
405        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
406
407    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
408        local_var_req_builder =
409            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
410    }
411    local_var_req_builder =
412        local_var_req_builder.json(&get_compressed_account_balance_post_request);
413
414    let local_var_req = local_var_req_builder.build()?;
415    let local_var_resp = local_var_client.execute(local_var_req).await?;
416
417    let local_var_status = local_var_resp.status();
418    let local_var_content = local_var_resp.text().await?;
419
420    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
421        serde_json::from_str(&local_var_content).map_err(Error::from)
422    } else {
423        let local_var_entity: Option<GetCompressedAccountBalancePostError> =
424            serde_json::from_str(&local_var_content).ok();
425        let local_var_error = ResponseContent {
426            status: local_var_status,
427            content: local_var_content,
428            entity: local_var_entity,
429        };
430        Err(Error::ResponseError(local_var_error))
431    }
432}
433
434pub async fn get_compressed_account_post(
435    configuration: &configuration::Configuration,
436    get_compressed_account_post_request: models::GetCompressedAccountPostRequest,
437) -> Result<models::GetCompressedAccountPost200Response, Error<GetCompressedAccountPostError>> {
438    let local_var_configuration = configuration;
439
440    let local_var_client = &local_var_configuration.client;
441
442    let local_var_uri_str = format!("{}/getCompressedAccount", local_var_configuration.base_path);
443    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
444    let mut local_var_req_builder =
445        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
446
447    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
448        local_var_req_builder =
449            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
450    }
451    local_var_req_builder = local_var_req_builder.json(&get_compressed_account_post_request);
452
453    let local_var_req = local_var_req_builder.build()?;
454    let local_var_resp = local_var_client.execute(local_var_req).await?;
455
456    let local_var_status = local_var_resp.status();
457    let local_var_content = local_var_resp.text().await?;
458
459    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
460        serde_json::from_str(&local_var_content).map_err(Error::from)
461    } else {
462        let local_var_entity: Option<GetCompressedAccountPostError> =
463            serde_json::from_str(&local_var_content).ok();
464        let local_var_error = ResponseContent {
465            status: local_var_status,
466            content: local_var_content,
467            entity: local_var_entity,
468        };
469        Err(Error::ResponseError(local_var_error))
470    }
471}
472
473pub async fn get_compressed_account_proof_post(
474    configuration: &configuration::Configuration,
475    get_compressed_account_proof_post_request: models::GetCompressedAccountProofPostRequest,
476) -> Result<
477    models::GetCompressedAccountProofPost200Response,
478    Error<GetCompressedAccountProofPostError>,
479> {
480    let local_var_configuration = configuration;
481
482    let local_var_client = &local_var_configuration.client;
483
484    let local_var_uri_str = format!(
485        "{}/getCompressedAccountProof",
486        local_var_configuration.base_path
487    );
488    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
489    let mut local_var_req_builder =
490        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
491
492    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
493        local_var_req_builder =
494            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
495    }
496    local_var_req_builder = local_var_req_builder.json(&get_compressed_account_proof_post_request);
497
498    let local_var_req = local_var_req_builder.build()?;
499    let local_var_resp = local_var_client.execute(local_var_req).await?;
500
501    let local_var_status = local_var_resp.status();
502    let local_var_content = local_var_resp.text().await?;
503
504    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
505        serde_json::from_str(&local_var_content).map_err(Error::from)
506    } else {
507        let local_var_entity: Option<GetCompressedAccountProofPostError> =
508            serde_json::from_str(&local_var_content).ok();
509        let local_var_error = ResponseContent {
510            status: local_var_status,
511            content: local_var_content,
512            entity: local_var_entity,
513        };
514        Err(Error::ResponseError(local_var_error))
515    }
516}
517
518pub async fn get_compressed_account_proof_v2_post(
519    configuration: &configuration::Configuration,
520    get_compressed_account_proof_v2_post_request: models::GetCompressedAccountProofV2PostRequest,
521) -> Result<
522    models::GetCompressedAccountProofV2Post200Response,
523    Error<GetCompressedAccountProofV2PostError>,
524> {
525    let local_var_configuration = configuration;
526
527    let local_var_client = &local_var_configuration.client;
528
529    let local_var_uri_str = format!(
530        "{}/getCompressedAccountProofV2",
531        local_var_configuration.base_path
532    );
533    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
534    let mut local_var_req_builder =
535        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
536
537    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
538        local_var_req_builder =
539            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
540    }
541    local_var_req_builder =
542        local_var_req_builder.json(&get_compressed_account_proof_v2_post_request);
543
544    let local_var_req = local_var_req_builder.build()?;
545    let local_var_resp = local_var_client.execute(local_var_req).await?;
546
547    let local_var_status = local_var_resp.status();
548    let local_var_content = local_var_resp.text().await?;
549
550    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
551        serde_json::from_str(&local_var_content).map_err(Error::from)
552    } else {
553        let local_var_entity: Option<GetCompressedAccountProofV2PostError> =
554            serde_json::from_str(&local_var_content).ok();
555        let local_var_error = ResponseContent {
556            status: local_var_status,
557            content: local_var_content,
558            entity: local_var_entity,
559        };
560        Err(Error::ResponseError(local_var_error))
561    }
562}
563
564pub async fn get_compressed_account_v2_post(
565    configuration: &configuration::Configuration,
566    get_compressed_account_v2_post_request: models::GetCompressedAccountV2PostRequest,
567) -> Result<models::GetCompressedAccountV2Post200Response, Error<GetCompressedAccountV2PostError>> {
568    let local_var_configuration = configuration;
569
570    let local_var_client = &local_var_configuration.client;
571
572    let local_var_uri_str = format!(
573        "{}/getCompressedAccountV2",
574        local_var_configuration.base_path
575    );
576    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
577    let mut local_var_req_builder =
578        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
579
580    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
581        local_var_req_builder =
582            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
583    }
584    local_var_req_builder = local_var_req_builder.json(&get_compressed_account_v2_post_request);
585
586    let local_var_req = local_var_req_builder.build()?;
587    let local_var_resp = local_var_client.execute(local_var_req).await?;
588
589    let local_var_status = local_var_resp.status();
590    let local_var_content = local_var_resp.text().await?;
591
592    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
593        serde_json::from_str(&local_var_content).map_err(Error::from)
594    } else {
595        let local_var_entity: Option<GetCompressedAccountV2PostError> =
596            serde_json::from_str(&local_var_content).ok();
597        let local_var_error = ResponseContent {
598            status: local_var_status,
599            content: local_var_content,
600            entity: local_var_entity,
601        };
602        Err(Error::ResponseError(local_var_error))
603    }
604}
605
606pub async fn get_compressed_accounts_by_owner_post(
607    configuration: &configuration::Configuration,
608    get_compressed_accounts_by_owner_post_request: models::GetCompressedAccountsByOwnerPostRequest,
609) -> Result<
610    models::GetCompressedAccountsByOwnerPost200Response,
611    Error<GetCompressedAccountsByOwnerPostError>,
612> {
613    let local_var_configuration = configuration;
614
615    let local_var_client = &local_var_configuration.client;
616
617    let local_var_uri_str = format!(
618        "{}/getCompressedAccountsByOwner",
619        local_var_configuration.base_path
620    );
621    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
622    let mut local_var_req_builder =
623        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
624
625    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
626        local_var_req_builder =
627            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
628    }
629    local_var_req_builder =
630        local_var_req_builder.json(&get_compressed_accounts_by_owner_post_request);
631
632    let local_var_req = local_var_req_builder.build()?;
633    let local_var_resp = local_var_client.execute(local_var_req).await?;
634
635    let local_var_status = local_var_resp.status();
636    let local_var_content = local_var_resp.text().await?;
637
638    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
639        serde_json::from_str(&local_var_content).map_err(Error::from)
640    } else {
641        let local_var_entity: Option<GetCompressedAccountsByOwnerPostError> =
642            serde_json::from_str(&local_var_content).ok();
643        let local_var_error = ResponseContent {
644            status: local_var_status,
645            content: local_var_content,
646            entity: local_var_entity,
647        };
648        Err(Error::ResponseError(local_var_error))
649    }
650}
651
652pub async fn get_compressed_accounts_by_owner_v2_post(
653    configuration: &configuration::Configuration,
654    get_compressed_accounts_by_owner_v2_post_request: models::GetCompressedAccountsByOwnerV2PostRequest,
655) -> Result<
656    models::GetCompressedAccountsByOwnerV2Post200Response,
657    Error<GetCompressedAccountsByOwnerV2PostError>,
658> {
659    let local_var_configuration = configuration;
660
661    let local_var_client = &local_var_configuration.client;
662
663    let local_var_uri_str = format!(
664        "{}/getCompressedAccountsByOwnerV2",
665        local_var_configuration.base_path
666    );
667    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
668    let mut local_var_req_builder =
669        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
670
671    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
672        local_var_req_builder =
673            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
674    }
675    local_var_req_builder =
676        local_var_req_builder.json(&get_compressed_accounts_by_owner_v2_post_request);
677
678    let local_var_req = local_var_req_builder.build()?;
679    let local_var_resp = local_var_client.execute(local_var_req).await?;
680
681    let local_var_status = local_var_resp.status();
682    let local_var_content = local_var_resp.text().await?;
683
684    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
685        serde_json::from_str(&local_var_content).map_err(Error::from)
686    } else {
687        let local_var_entity: Option<GetCompressedAccountsByOwnerV2PostError> =
688            serde_json::from_str(&local_var_content).ok();
689        let local_var_error = ResponseContent {
690            status: local_var_status,
691            content: local_var_content,
692            entity: local_var_entity,
693        };
694        Err(Error::ResponseError(local_var_error))
695    }
696}
697
698pub async fn get_compressed_balance_by_owner_post(
699    configuration: &configuration::Configuration,
700    get_compressed_balance_by_owner_post_request: models::GetCompressedBalanceByOwnerPostRequest,
701) -> Result<
702    models::GetCompressedAccountBalancePost200Response,
703    Error<GetCompressedBalanceByOwnerPostError>,
704> {
705    let local_var_configuration = configuration;
706
707    let local_var_client = &local_var_configuration.client;
708
709    let local_var_uri_str = format!(
710        "{}/getCompressedBalanceByOwner",
711        local_var_configuration.base_path
712    );
713    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
714    let mut local_var_req_builder =
715        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
716
717    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
718        local_var_req_builder =
719            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
720    }
721    local_var_req_builder =
722        local_var_req_builder.json(&get_compressed_balance_by_owner_post_request);
723
724    let local_var_req = local_var_req_builder.build()?;
725    let local_var_resp = local_var_client.execute(local_var_req).await?;
726
727    let local_var_status = local_var_resp.status();
728    let local_var_content = local_var_resp.text().await?;
729
730    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
731        serde_json::from_str(&local_var_content).map_err(Error::from)
732    } else {
733        let local_var_entity: Option<GetCompressedBalanceByOwnerPostError> =
734            serde_json::from_str(&local_var_content).ok();
735        let local_var_error = ResponseContent {
736            status: local_var_status,
737            content: local_var_content,
738            entity: local_var_entity,
739        };
740        Err(Error::ResponseError(local_var_error))
741    }
742}
743
744pub async fn get_compressed_mint_token_holders_post(
745    configuration: &configuration::Configuration,
746    get_compressed_mint_token_holders_post_request: models::GetCompressedMintTokenHoldersPostRequest,
747) -> Result<
748    models::GetCompressedMintTokenHoldersPost200Response,
749    Error<GetCompressedMintTokenHoldersPostError>,
750> {
751    let local_var_configuration = configuration;
752
753    let local_var_client = &local_var_configuration.client;
754
755    let local_var_uri_str = format!(
756        "{}/getCompressedMintTokenHolders",
757        local_var_configuration.base_path
758    );
759    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
760    let mut local_var_req_builder =
761        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
762
763    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
764        local_var_req_builder =
765            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
766    }
767    local_var_req_builder =
768        local_var_req_builder.json(&get_compressed_mint_token_holders_post_request);
769
770    let local_var_req = local_var_req_builder.build()?;
771    let local_var_resp = local_var_client.execute(local_var_req).await?;
772
773    let local_var_status = local_var_resp.status();
774    let local_var_content = local_var_resp.text().await?;
775
776    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
777        serde_json::from_str(&local_var_content).map_err(Error::from)
778    } else {
779        let local_var_entity: Option<GetCompressedMintTokenHoldersPostError> =
780            serde_json::from_str(&local_var_content).ok();
781        let local_var_error = ResponseContent {
782            status: local_var_status,
783            content: local_var_content,
784            entity: local_var_entity,
785        };
786        Err(Error::ResponseError(local_var_error))
787    }
788}
789
790pub async fn get_compressed_token_account_balance_post(
791    configuration: &configuration::Configuration,
792    get_compressed_token_account_balance_post_request: models::GetCompressedTokenAccountBalancePostRequest,
793) -> Result<
794    models::GetCompressedTokenAccountBalancePost200Response,
795    Error<GetCompressedTokenAccountBalancePostError>,
796> {
797    let local_var_configuration = configuration;
798
799    let local_var_client = &local_var_configuration.client;
800
801    let local_var_uri_str = format!(
802        "{}/getCompressedTokenAccountBalance",
803        local_var_configuration.base_path
804    );
805    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
806    let mut local_var_req_builder =
807        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
808
809    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
810        local_var_req_builder =
811            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
812    }
813    local_var_req_builder =
814        local_var_req_builder.json(&get_compressed_token_account_balance_post_request);
815
816    let local_var_req = local_var_req_builder.build()?;
817    let local_var_resp = local_var_client.execute(local_var_req).await?;
818
819    let local_var_status = local_var_resp.status();
820    let local_var_content = local_var_resp.text().await?;
821
822    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
823        serde_json::from_str(&local_var_content).map_err(Error::from)
824    } else {
825        let local_var_entity: Option<GetCompressedTokenAccountBalancePostError> =
826            serde_json::from_str(&local_var_content).ok();
827        let local_var_error = ResponseContent {
828            status: local_var_status,
829            content: local_var_content,
830            entity: local_var_entity,
831        };
832        Err(Error::ResponseError(local_var_error))
833    }
834}
835
836pub async fn get_compressed_token_accounts_by_delegate_post(
837    configuration: &configuration::Configuration,
838    get_compressed_token_accounts_by_delegate_post_request: models::GetCompressedTokenAccountsByDelegatePostRequest,
839) -> Result<
840    models::GetCompressedTokenAccountsByDelegatePost200Response,
841    Error<GetCompressedTokenAccountsByDelegatePostError>,
842> {
843    let local_var_configuration = configuration;
844
845    let local_var_client = &local_var_configuration.client;
846
847    let local_var_uri_str = format!(
848        "{}/getCompressedTokenAccountsByDelegate",
849        local_var_configuration.base_path
850    );
851    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
852    let mut local_var_req_builder =
853        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
854
855    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
856        local_var_req_builder =
857            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
858    }
859    local_var_req_builder =
860        local_var_req_builder.json(&get_compressed_token_accounts_by_delegate_post_request);
861
862    let local_var_req = local_var_req_builder.build()?;
863    let local_var_resp = local_var_client.execute(local_var_req).await?;
864
865    let local_var_status = local_var_resp.status();
866    let local_var_content = local_var_resp.text().await?;
867
868    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
869        serde_json::from_str(&local_var_content).map_err(Error::from)
870    } else {
871        let local_var_entity: Option<GetCompressedTokenAccountsByDelegatePostError> =
872            serde_json::from_str(&local_var_content).ok();
873        let local_var_error = ResponseContent {
874            status: local_var_status,
875            content: local_var_content,
876            entity: local_var_entity,
877        };
878        Err(Error::ResponseError(local_var_error))
879    }
880}
881
882pub async fn get_compressed_token_accounts_by_delegate_v2_post(
883    configuration: &configuration::Configuration,
884    get_compressed_token_accounts_by_delegate_v2_post_request: models::GetCompressedTokenAccountsByDelegateV2PostRequest,
885) -> Result<
886    models::GetCompressedTokenAccountsByDelegateV2Post200Response,
887    Error<GetCompressedTokenAccountsByDelegateV2PostError>,
888> {
889    let local_var_configuration = configuration;
890
891    let local_var_client = &local_var_configuration.client;
892
893    let local_var_uri_str = format!(
894        "{}/getCompressedTokenAccountsByDelegateV2",
895        local_var_configuration.base_path
896    );
897    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
898    let mut local_var_req_builder =
899        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
900
901    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
902        local_var_req_builder =
903            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
904    }
905    local_var_req_builder =
906        local_var_req_builder.json(&get_compressed_token_accounts_by_delegate_v2_post_request);
907
908    let local_var_req = local_var_req_builder.build()?;
909    let local_var_resp = local_var_client.execute(local_var_req).await?;
910
911    let local_var_status = local_var_resp.status();
912    let local_var_content = local_var_resp.text().await?;
913
914    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
915        serde_json::from_str(&local_var_content).map_err(Error::from)
916    } else {
917        let local_var_entity: Option<GetCompressedTokenAccountsByDelegateV2PostError> =
918            serde_json::from_str(&local_var_content).ok();
919        let local_var_error = ResponseContent {
920            status: local_var_status,
921            content: local_var_content,
922            entity: local_var_entity,
923        };
924        Err(Error::ResponseError(local_var_error))
925    }
926}
927
928pub async fn get_compressed_token_accounts_by_owner_post(
929    configuration: &configuration::Configuration,
930    get_compressed_token_accounts_by_owner_post_request: models::GetCompressedTokenAccountsByOwnerPostRequest,
931) -> Result<
932    models::GetCompressedTokenAccountsByDelegatePost200Response,
933    Error<GetCompressedTokenAccountsByOwnerPostError>,
934> {
935    let local_var_configuration = configuration;
936
937    let local_var_client = &local_var_configuration.client;
938
939    let local_var_uri_str = format!(
940        "{}/getCompressedTokenAccountsByOwner",
941        local_var_configuration.base_path
942    );
943    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
944    let mut local_var_req_builder =
945        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
946
947    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
948        local_var_req_builder =
949            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
950    }
951    local_var_req_builder =
952        local_var_req_builder.json(&get_compressed_token_accounts_by_owner_post_request);
953
954    let local_var_req = local_var_req_builder.build()?;
955    let local_var_resp = local_var_client.execute(local_var_req).await?;
956
957    let local_var_status = local_var_resp.status();
958    let local_var_content = local_var_resp.text().await?;
959
960    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
961        serde_json::from_str(&local_var_content).map_err(Error::from)
962    } else {
963        let local_var_entity: Option<GetCompressedTokenAccountsByOwnerPostError> =
964            serde_json::from_str(&local_var_content).ok();
965        let local_var_error = ResponseContent {
966            status: local_var_status,
967            content: local_var_content,
968            entity: local_var_entity,
969        };
970        Err(Error::ResponseError(local_var_error))
971    }
972}
973
974pub async fn get_compressed_token_accounts_by_owner_v2_post(
975    configuration: &configuration::Configuration,
976    get_compressed_token_accounts_by_owner_v2_post_request: models::GetCompressedTokenAccountsByOwnerV2PostRequest,
977) -> Result<
978    models::GetCompressedTokenAccountsByDelegateV2Post200Response,
979    Error<GetCompressedTokenAccountsByOwnerV2PostError>,
980> {
981    let local_var_configuration = configuration;
982
983    let local_var_client = &local_var_configuration.client;
984
985    let local_var_uri_str = format!(
986        "{}/getCompressedTokenAccountsByOwnerV2",
987        local_var_configuration.base_path
988    );
989    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
990    let mut local_var_req_builder =
991        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
992
993    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
994        local_var_req_builder =
995            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
996    }
997    local_var_req_builder =
998        local_var_req_builder.json(&get_compressed_token_accounts_by_owner_v2_post_request);
999
1000    let local_var_req = local_var_req_builder.build()?;
1001    let local_var_resp = local_var_client.execute(local_var_req).await?;
1002
1003    let local_var_status = local_var_resp.status();
1004    let local_var_content = local_var_resp.text().await?;
1005
1006    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1007        serde_json::from_str(&local_var_content).map_err(Error::from)
1008    } else {
1009        let local_var_entity: Option<GetCompressedTokenAccountsByOwnerV2PostError> =
1010            serde_json::from_str(&local_var_content).ok();
1011        let local_var_error = ResponseContent {
1012            status: local_var_status,
1013            content: local_var_content,
1014            entity: local_var_entity,
1015        };
1016        Err(Error::ResponseError(local_var_error))
1017    }
1018}
1019
1020pub async fn get_compressed_token_balances_by_owner_post(
1021    configuration: &configuration::Configuration,
1022    get_compressed_token_balances_by_owner_post_request: models::GetCompressedTokenBalancesByOwnerPostRequest,
1023) -> Result<
1024    models::GetCompressedTokenBalancesByOwnerPost200Response,
1025    Error<GetCompressedTokenBalancesByOwnerPostError>,
1026> {
1027    let local_var_configuration = configuration;
1028
1029    let local_var_client = &local_var_configuration.client;
1030
1031    let local_var_uri_str = format!(
1032        "{}/getCompressedTokenBalancesByOwner",
1033        local_var_configuration.base_path
1034    );
1035    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1036    let mut local_var_req_builder =
1037        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1038
1039    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1040        local_var_req_builder =
1041            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1042    }
1043    local_var_req_builder =
1044        local_var_req_builder.json(&get_compressed_token_balances_by_owner_post_request);
1045
1046    let local_var_req = local_var_req_builder.build()?;
1047    let local_var_resp = local_var_client.execute(local_var_req).await?;
1048
1049    let local_var_status = local_var_resp.status();
1050    let local_var_content = local_var_resp.text().await?;
1051
1052    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1053        serde_json::from_str(&local_var_content).map_err(Error::from)
1054    } else {
1055        let local_var_entity: Option<GetCompressedTokenBalancesByOwnerPostError> =
1056            serde_json::from_str(&local_var_content).ok();
1057        let local_var_error = ResponseContent {
1058            status: local_var_status,
1059            content: local_var_content,
1060            entity: local_var_entity,
1061        };
1062        Err(Error::ResponseError(local_var_error))
1063    }
1064}
1065
1066pub async fn get_compressed_token_balances_by_owner_v2_post(
1067    configuration: &configuration::Configuration,
1068    get_compressed_token_balances_by_owner_v2_post_request: models::GetCompressedTokenBalancesByOwnerV2PostRequest,
1069) -> Result<
1070    models::GetCompressedTokenBalancesByOwnerV2Post200Response,
1071    Error<GetCompressedTokenBalancesByOwnerV2PostError>,
1072> {
1073    let local_var_configuration = configuration;
1074
1075    let local_var_client = &local_var_configuration.client;
1076
1077    let local_var_uri_str = format!(
1078        "{}/getCompressedTokenBalancesByOwnerV2",
1079        local_var_configuration.base_path
1080    );
1081    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1082    let mut local_var_req_builder =
1083        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1084
1085    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1086        local_var_req_builder =
1087            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1088    }
1089    local_var_req_builder =
1090        local_var_req_builder.json(&get_compressed_token_balances_by_owner_v2_post_request);
1091
1092    let local_var_req = local_var_req_builder.build()?;
1093    let local_var_resp = local_var_client.execute(local_var_req).await?;
1094
1095    let local_var_status = local_var_resp.status();
1096    let local_var_content = local_var_resp.text().await?;
1097
1098    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1099        serde_json::from_str(&local_var_content).map_err(Error::from)
1100    } else {
1101        let local_var_entity: Option<GetCompressedTokenBalancesByOwnerV2PostError> =
1102            serde_json::from_str(&local_var_content).ok();
1103        let local_var_error = ResponseContent {
1104            status: local_var_status,
1105            content: local_var_content,
1106            entity: local_var_entity,
1107        };
1108        Err(Error::ResponseError(local_var_error))
1109    }
1110}
1111
1112pub async fn get_compression_signatures_for_account_post(
1113    configuration: &configuration::Configuration,
1114    get_compression_signatures_for_account_post_request: models::GetCompressionSignaturesForAccountPostRequest,
1115) -> Result<
1116    models::GetCompressionSignaturesForAccountPost200Response,
1117    Error<GetCompressionSignaturesForAccountPostError>,
1118> {
1119    let local_var_configuration = configuration;
1120
1121    let local_var_client = &local_var_configuration.client;
1122
1123    let local_var_uri_str = format!(
1124        "{}/getCompressionSignaturesForAccount",
1125        local_var_configuration.base_path
1126    );
1127    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1128    let mut local_var_req_builder =
1129        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1130
1131    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1132        local_var_req_builder =
1133            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1134    }
1135    local_var_req_builder =
1136        local_var_req_builder.json(&get_compression_signatures_for_account_post_request);
1137
1138    let local_var_req = local_var_req_builder.build()?;
1139    let local_var_resp = local_var_client.execute(local_var_req).await?;
1140
1141    let local_var_status = local_var_resp.status();
1142    let local_var_content = local_var_resp.text().await?;
1143
1144    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1145        serde_json::from_str(&local_var_content).map_err(Error::from)
1146    } else {
1147        let local_var_entity: Option<GetCompressionSignaturesForAccountPostError> =
1148            serde_json::from_str(&local_var_content).ok();
1149        let local_var_error = ResponseContent {
1150            status: local_var_status,
1151            content: local_var_content,
1152            entity: local_var_entity,
1153        };
1154        Err(Error::ResponseError(local_var_error))
1155    }
1156}
1157
1158pub async fn get_compression_signatures_for_address_post(
1159    configuration: &configuration::Configuration,
1160    get_compression_signatures_for_address_post_request: models::GetCompressionSignaturesForAddressPostRequest,
1161) -> Result<
1162    models::GetCompressionSignaturesForAddressPost200Response,
1163    Error<GetCompressionSignaturesForAddressPostError>,
1164> {
1165    let local_var_configuration = configuration;
1166
1167    let local_var_client = &local_var_configuration.client;
1168
1169    let local_var_uri_str = format!(
1170        "{}/getCompressionSignaturesForAddress",
1171        local_var_configuration.base_path
1172    );
1173    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1174    let mut local_var_req_builder =
1175        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1176
1177    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1178        local_var_req_builder =
1179            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1180    }
1181    local_var_req_builder =
1182        local_var_req_builder.json(&get_compression_signatures_for_address_post_request);
1183
1184    let local_var_req = local_var_req_builder.build()?;
1185    let local_var_resp = local_var_client.execute(local_var_req).await?;
1186
1187    let local_var_status = local_var_resp.status();
1188    let local_var_content = local_var_resp.text().await?;
1189
1190    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1191        serde_json::from_str(&local_var_content).map_err(Error::from)
1192    } else {
1193        let local_var_entity: Option<GetCompressionSignaturesForAddressPostError> =
1194            serde_json::from_str(&local_var_content).ok();
1195        let local_var_error = ResponseContent {
1196            status: local_var_status,
1197            content: local_var_content,
1198            entity: local_var_entity,
1199        };
1200        Err(Error::ResponseError(local_var_error))
1201    }
1202}
1203
1204pub async fn get_compression_signatures_for_owner_post(
1205    configuration: &configuration::Configuration,
1206    get_compression_signatures_for_owner_post_request: models::GetCompressionSignaturesForOwnerPostRequest,
1207) -> Result<
1208    models::GetCompressionSignaturesForAddressPost200Response,
1209    Error<GetCompressionSignaturesForOwnerPostError>,
1210> {
1211    let local_var_configuration = configuration;
1212
1213    let local_var_client = &local_var_configuration.client;
1214
1215    let local_var_uri_str = format!(
1216        "{}/getCompressionSignaturesForOwner",
1217        local_var_configuration.base_path
1218    );
1219    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1220    let mut local_var_req_builder =
1221        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1222
1223    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1224        local_var_req_builder =
1225            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1226    }
1227    local_var_req_builder =
1228        local_var_req_builder.json(&get_compression_signatures_for_owner_post_request);
1229
1230    let local_var_req = local_var_req_builder.build()?;
1231    let local_var_resp = local_var_client.execute(local_var_req).await?;
1232
1233    let local_var_status = local_var_resp.status();
1234    let local_var_content = local_var_resp.text().await?;
1235
1236    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1237        serde_json::from_str(&local_var_content).map_err(Error::from)
1238    } else {
1239        let local_var_entity: Option<GetCompressionSignaturesForOwnerPostError> =
1240            serde_json::from_str(&local_var_content).ok();
1241        let local_var_error = ResponseContent {
1242            status: local_var_status,
1243            content: local_var_content,
1244            entity: local_var_entity,
1245        };
1246        Err(Error::ResponseError(local_var_error))
1247    }
1248}
1249
1250pub async fn get_compression_signatures_for_token_owner_post(
1251    configuration: &configuration::Configuration,
1252    get_compression_signatures_for_token_owner_post_request: models::GetCompressionSignaturesForTokenOwnerPostRequest,
1253) -> Result<
1254    models::GetCompressionSignaturesForAddressPost200Response,
1255    Error<GetCompressionSignaturesForTokenOwnerPostError>,
1256> {
1257    let local_var_configuration = configuration;
1258
1259    let local_var_client = &local_var_configuration.client;
1260
1261    let local_var_uri_str = format!(
1262        "{}/getCompressionSignaturesForTokenOwner",
1263        local_var_configuration.base_path
1264    );
1265    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1266    let mut local_var_req_builder =
1267        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1268
1269    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1270        local_var_req_builder =
1271            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1272    }
1273    local_var_req_builder =
1274        local_var_req_builder.json(&get_compression_signatures_for_token_owner_post_request);
1275
1276    let local_var_req = local_var_req_builder.build()?;
1277    let local_var_resp = local_var_client.execute(local_var_req).await?;
1278
1279    let local_var_status = local_var_resp.status();
1280    let local_var_content = local_var_resp.text().await?;
1281
1282    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1283        serde_json::from_str(&local_var_content).map_err(Error::from)
1284    } else {
1285        let local_var_entity: Option<GetCompressionSignaturesForTokenOwnerPostError> =
1286            serde_json::from_str(&local_var_content).ok();
1287        let local_var_error = ResponseContent {
1288            status: local_var_status,
1289            content: local_var_content,
1290            entity: local_var_entity,
1291        };
1292        Err(Error::ResponseError(local_var_error))
1293    }
1294}
1295
1296pub async fn get_indexer_health_post(
1297    configuration: &configuration::Configuration,
1298    get_indexer_health_post_request: models::GetIndexerHealthPostRequest,
1299) -> Result<models::GetIndexerHealthPost200Response, Error<GetIndexerHealthPostError>> {
1300    let local_var_configuration = configuration;
1301
1302    let local_var_client = &local_var_configuration.client;
1303
1304    let local_var_uri_str = format!("{}/getIndexerHealth", local_var_configuration.base_path);
1305    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1306    let mut local_var_req_builder =
1307        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1308
1309    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1310        local_var_req_builder =
1311            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1312    }
1313    local_var_req_builder = local_var_req_builder.json(&get_indexer_health_post_request);
1314
1315    let local_var_req = local_var_req_builder.build()?;
1316    let local_var_resp = local_var_client.execute(local_var_req).await?;
1317
1318    let local_var_status = local_var_resp.status();
1319    let local_var_content = local_var_resp.text().await?;
1320
1321    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1322        serde_json::from_str(&local_var_content).map_err(Error::from)
1323    } else {
1324        let local_var_entity: Option<GetIndexerHealthPostError> =
1325            serde_json::from_str(&local_var_content).ok();
1326        let local_var_error = ResponseContent {
1327            status: local_var_status,
1328            content: local_var_content,
1329            entity: local_var_entity,
1330        };
1331        Err(Error::ResponseError(local_var_error))
1332    }
1333}
1334
1335pub async fn get_indexer_slot_post(
1336    configuration: &configuration::Configuration,
1337    get_indexer_slot_post_request: models::GetIndexerSlotPostRequest,
1338) -> Result<models::GetIndexerSlotPost200Response, Error<GetIndexerSlotPostError>> {
1339    let local_var_configuration = configuration;
1340
1341    let local_var_client = &local_var_configuration.client;
1342
1343    let local_var_uri_str = format!("{}/getIndexerSlot", local_var_configuration.base_path);
1344    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1345    let mut local_var_req_builder =
1346        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1347
1348    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1349        local_var_req_builder =
1350            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1351    }
1352    local_var_req_builder = local_var_req_builder.json(&get_indexer_slot_post_request);
1353
1354    let local_var_req = local_var_req_builder.build()?;
1355    let local_var_resp = local_var_client.execute(local_var_req).await?;
1356
1357    let local_var_status = local_var_resp.status();
1358    let local_var_content = local_var_resp.text().await?;
1359
1360    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1361        serde_json::from_str(&local_var_content).map_err(Error::from)
1362    } else {
1363        let local_var_entity: Option<GetIndexerSlotPostError> =
1364            serde_json::from_str(&local_var_content).ok();
1365        let local_var_error = ResponseContent {
1366            status: local_var_status,
1367            content: local_var_content,
1368            entity: local_var_entity,
1369        };
1370        Err(Error::ResponseError(local_var_error))
1371    }
1372}
1373
1374pub async fn get_latest_compression_signatures_post(
1375    configuration: &configuration::Configuration,
1376    get_latest_compression_signatures_post_request: models::GetLatestCompressionSignaturesPostRequest,
1377) -> Result<
1378    models::GetCompressionSignaturesForAddressPost200Response,
1379    Error<GetLatestCompressionSignaturesPostError>,
1380> {
1381    let local_var_configuration = configuration;
1382
1383    let local_var_client = &local_var_configuration.client;
1384
1385    let local_var_uri_str = format!(
1386        "{}/getLatestCompressionSignatures",
1387        local_var_configuration.base_path
1388    );
1389    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1390    let mut local_var_req_builder =
1391        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1392
1393    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1394        local_var_req_builder =
1395            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1396    }
1397    local_var_req_builder =
1398        local_var_req_builder.json(&get_latest_compression_signatures_post_request);
1399
1400    let local_var_req = local_var_req_builder.build()?;
1401    let local_var_resp = local_var_client.execute(local_var_req).await?;
1402
1403    let local_var_status = local_var_resp.status();
1404    let local_var_content = local_var_resp.text().await?;
1405
1406    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1407        serde_json::from_str(&local_var_content).map_err(Error::from)
1408    } else {
1409        let local_var_entity: Option<GetLatestCompressionSignaturesPostError> =
1410            serde_json::from_str(&local_var_content).ok();
1411        let local_var_error = ResponseContent {
1412            status: local_var_status,
1413            content: local_var_content,
1414            entity: local_var_entity,
1415        };
1416        Err(Error::ResponseError(local_var_error))
1417    }
1418}
1419
1420pub async fn get_latest_non_voting_signatures_post(
1421    configuration: &configuration::Configuration,
1422    get_latest_non_voting_signatures_post_request: models::GetLatestNonVotingSignaturesPostRequest,
1423) -> Result<
1424    models::GetLatestNonVotingSignaturesPost200Response,
1425    Error<GetLatestNonVotingSignaturesPostError>,
1426> {
1427    let local_var_configuration = configuration;
1428
1429    let local_var_client = &local_var_configuration.client;
1430
1431    let local_var_uri_str = format!(
1432        "{}/getLatestNonVotingSignatures",
1433        local_var_configuration.base_path
1434    );
1435    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1436    let mut local_var_req_builder =
1437        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1438
1439    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1440        local_var_req_builder =
1441            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1442    }
1443    local_var_req_builder =
1444        local_var_req_builder.json(&get_latest_non_voting_signatures_post_request);
1445
1446    let local_var_req = local_var_req_builder.build()?;
1447    let local_var_resp = local_var_client.execute(local_var_req).await?;
1448
1449    let local_var_status = local_var_resp.status();
1450    let local_var_content = local_var_resp.text().await?;
1451
1452    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1453        serde_json::from_str(&local_var_content).map_err(Error::from)
1454    } else {
1455        let local_var_entity: Option<GetLatestNonVotingSignaturesPostError> =
1456            serde_json::from_str(&local_var_content).ok();
1457        let local_var_error = ResponseContent {
1458            status: local_var_status,
1459            content: local_var_content,
1460            entity: local_var_entity,
1461        };
1462        Err(Error::ResponseError(local_var_error))
1463    }
1464}
1465
1466pub async fn get_multiple_compressed_account_proofs_post(
1467    configuration: &configuration::Configuration,
1468    get_multiple_compressed_account_proofs_post_request: models::GetMultipleCompressedAccountProofsPostRequest,
1469) -> Result<
1470    models::GetMultipleCompressedAccountProofsPost200Response,
1471    Error<GetMultipleCompressedAccountProofsPostError>,
1472> {
1473    let local_var_configuration = configuration;
1474
1475    let local_var_client = &local_var_configuration.client;
1476
1477    let local_var_uri_str = format!(
1478        "{}/getMultipleCompressedAccountProofs",
1479        local_var_configuration.base_path
1480    );
1481    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1482
1483    let mut local_var_req_builder =
1484        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1485
1486    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1487        local_var_req_builder =
1488            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1489    }
1490    local_var_req_builder =
1491        local_var_req_builder.json(&get_multiple_compressed_account_proofs_post_request);
1492
1493    let local_var_req = local_var_req_builder.build()?;
1494    let local_var_resp = local_var_client.execute(local_var_req).await?;
1495
1496    let local_var_status = local_var_resp.status();
1497    let local_var_content = local_var_resp.text().await?;
1498
1499    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1500        serde_json::from_str(&local_var_content).map_err(Error::from)
1501    } else {
1502        let local_var_entity: Option<GetMultipleCompressedAccountProofsPostError> =
1503            serde_json::from_str(&local_var_content).ok();
1504        let local_var_error = ResponseContent {
1505            status: local_var_status,
1506            content: local_var_content,
1507            entity: local_var_entity,
1508        };
1509        Err(Error::ResponseError(local_var_error))
1510    }
1511}
1512
1513pub async fn get_multiple_compressed_account_proofs_v2_post(
1514    configuration: &configuration::Configuration,
1515    get_multiple_compressed_account_proofs_v2_post_request: models::GetMultipleCompressedAccountProofsV2PostRequest,
1516) -> Result<
1517    models::GetMultipleCompressedAccountProofsV2Post200Response,
1518    Error<GetMultipleCompressedAccountProofsV2PostError>,
1519> {
1520    let local_var_configuration = configuration;
1521
1522    let local_var_client = &local_var_configuration.client;
1523
1524    let local_var_uri_str = format!(
1525        "{}/getMultipleCompressedAccountProofsV2",
1526        local_var_configuration.base_path
1527    );
1528    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1529    let mut local_var_req_builder =
1530        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1531
1532    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1533        local_var_req_builder =
1534            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1535    }
1536    local_var_req_builder =
1537        local_var_req_builder.json(&get_multiple_compressed_account_proofs_v2_post_request);
1538
1539    let local_var_req = local_var_req_builder.build()?;
1540    let local_var_resp = local_var_client.execute(local_var_req).await?;
1541
1542    let local_var_status = local_var_resp.status();
1543    let local_var_content = local_var_resp.text().await?;
1544
1545    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1546        serde_json::from_str(&local_var_content).map_err(Error::from)
1547    } else {
1548        let local_var_entity: Option<GetMultipleCompressedAccountProofsV2PostError> =
1549            serde_json::from_str(&local_var_content).ok();
1550        let local_var_error = ResponseContent {
1551            status: local_var_status,
1552            content: local_var_content,
1553            entity: local_var_entity,
1554        };
1555        Err(Error::ResponseError(local_var_error))
1556    }
1557}
1558
1559pub async fn get_multiple_compressed_accounts_post(
1560    configuration: &configuration::Configuration,
1561    get_multiple_compressed_accounts_post_request: models::GetMultipleCompressedAccountsPostRequest,
1562) -> Result<
1563    models::GetMultipleCompressedAccountsPost200Response,
1564    Error<GetMultipleCompressedAccountsPostError>,
1565> {
1566    let local_var_configuration = configuration;
1567
1568    let local_var_client = &local_var_configuration.client;
1569
1570    let local_var_uri_str = format!(
1571        "{}/getMultipleCompressedAccounts",
1572        local_var_configuration.base_path
1573    );
1574    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1575    let mut local_var_req_builder =
1576        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1577
1578    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1579        local_var_req_builder =
1580            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1581    }
1582    local_var_req_builder =
1583        local_var_req_builder.json(&get_multiple_compressed_accounts_post_request);
1584
1585    let local_var_req = local_var_req_builder.build()?;
1586    let local_var_resp = local_var_client.execute(local_var_req).await?;
1587
1588    let local_var_status = local_var_resp.status();
1589    let local_var_content = local_var_resp.text().await?;
1590
1591    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1592        serde_json::from_str(&local_var_content).map_err(Error::from)
1593    } else {
1594        let local_var_entity: Option<GetMultipleCompressedAccountsPostError> =
1595            serde_json::from_str(&local_var_content).ok();
1596        let local_var_error = ResponseContent {
1597            status: local_var_status,
1598            content: local_var_content,
1599            entity: local_var_entity,
1600        };
1601        Err(Error::ResponseError(local_var_error))
1602    }
1603}
1604
1605pub async fn get_multiple_compressed_accounts_v2_post(
1606    configuration: &configuration::Configuration,
1607    get_multiple_compressed_accounts_v2_post_request: models::GetMultipleCompressedAccountsV2PostRequest,
1608) -> Result<
1609    models::GetMultipleCompressedAccountsV2Post200Response,
1610    Error<GetMultipleCompressedAccountsV2PostError>,
1611> {
1612    let local_var_configuration = configuration;
1613
1614    let local_var_client = &local_var_configuration.client;
1615
1616    let local_var_uri_str = format!(
1617        "{}/getMultipleCompressedAccountsV2",
1618        local_var_configuration.base_path
1619    );
1620    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1621    let mut local_var_req_builder =
1622        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1623
1624    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1625        local_var_req_builder =
1626            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1627    }
1628    local_var_req_builder =
1629        local_var_req_builder.json(&get_multiple_compressed_accounts_v2_post_request);
1630
1631    let local_var_req = local_var_req_builder.build()?;
1632    let local_var_resp = local_var_client.execute(local_var_req).await?;
1633
1634    let local_var_status = local_var_resp.status();
1635    let local_var_content = local_var_resp.text().await?;
1636
1637    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1638        serde_json::from_str(&local_var_content).map_err(Error::from)
1639    } else {
1640        let local_var_entity: Option<GetMultipleCompressedAccountsV2PostError> =
1641            serde_json::from_str(&local_var_content).ok();
1642        let local_var_error = ResponseContent {
1643            status: local_var_status,
1644            content: local_var_content,
1645            entity: local_var_entity,
1646        };
1647        Err(Error::ResponseError(local_var_error))
1648    }
1649}
1650
1651pub async fn get_multiple_new_address_proofs_post(
1652    configuration: &configuration::Configuration,
1653    get_multiple_new_address_proofs_post_request: models::GetMultipleNewAddressProofsPostRequest,
1654) -> Result<
1655    models::GetMultipleNewAddressProofsPost200Response,
1656    Error<GetMultipleNewAddressProofsPostError>,
1657> {
1658    let local_var_configuration = configuration;
1659
1660    let local_var_client = &local_var_configuration.client;
1661
1662    let local_var_uri_str = format!(
1663        "{}/getMultipleNewAddressProofs",
1664        local_var_configuration.base_path
1665    );
1666    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1667    let mut local_var_req_builder =
1668        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1669
1670    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1671        local_var_req_builder =
1672            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1673    }
1674    local_var_req_builder =
1675        local_var_req_builder.json(&get_multiple_new_address_proofs_post_request);
1676
1677    let local_var_req = local_var_req_builder.build()?;
1678    let local_var_resp = local_var_client.execute(local_var_req).await?;
1679
1680    let local_var_status = local_var_resp.status();
1681    let local_var_content = local_var_resp.text().await?;
1682
1683    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1684        serde_json::from_str(&local_var_content).map_err(Error::from)
1685    } else {
1686        let local_var_entity: Option<GetMultipleNewAddressProofsPostError> =
1687            serde_json::from_str(&local_var_content).ok();
1688        let local_var_error = ResponseContent {
1689            status: local_var_status,
1690            content: local_var_content,
1691            entity: local_var_entity,
1692        };
1693        Err(Error::ResponseError(local_var_error))
1694    }
1695}
1696
1697pub async fn get_multiple_new_address_proofs_v2_post(
1698    configuration: &configuration::Configuration,
1699    get_multiple_new_address_proofs_v2_post_request: models::GetMultipleNewAddressProofsV2PostRequest,
1700) -> Result<
1701    models::GetMultipleNewAddressProofsPost200Response,
1702    Error<GetMultipleNewAddressProofsV2PostError>,
1703> {
1704    let local_var_configuration = configuration;
1705
1706    let local_var_client = &local_var_configuration.client;
1707
1708    let local_var_uri_str = format!(
1709        "{}/getMultipleNewAddressProofsV2",
1710        local_var_configuration.base_path
1711    );
1712    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1713    let mut local_var_req_builder =
1714        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1715
1716    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1717        local_var_req_builder =
1718            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1719    }
1720    local_var_req_builder =
1721        local_var_req_builder.json(&get_multiple_new_address_proofs_v2_post_request);
1722
1723    let local_var_req = local_var_req_builder.build()?;
1724    let local_var_resp = local_var_client.execute(local_var_req).await?;
1725
1726    let local_var_status = local_var_resp.status();
1727    let local_var_content = local_var_resp.text().await?;
1728
1729    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1730        serde_json::from_str(&local_var_content).map_err(Error::from)
1731    } else {
1732        let local_var_entity: Option<GetMultipleNewAddressProofsV2PostError> =
1733            serde_json::from_str(&local_var_content).ok();
1734        let local_var_error = ResponseContent {
1735            status: local_var_status,
1736            content: local_var_content,
1737            entity: local_var_entity,
1738        };
1739        Err(Error::ResponseError(local_var_error))
1740    }
1741}
1742
1743pub async fn get_queue_elements_post(
1744    configuration: &configuration::Configuration,
1745    get_queue_elements_post_request: models::GetQueueElementsPostRequest,
1746) -> Result<models::GetQueueElementsPost200Response, Error<GetQueueElementsPostError>> {
1747    let local_var_configuration = configuration;
1748
1749    let local_var_client = &local_var_configuration.client;
1750
1751    let local_var_uri_str = format!("{}/getQueueElements", local_var_configuration.base_path);
1752    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1753    let mut local_var_req_builder =
1754        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1755
1756    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1757        local_var_req_builder =
1758            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1759    }
1760    local_var_req_builder = local_var_req_builder.json(&get_queue_elements_post_request);
1761
1762    let local_var_req = local_var_req_builder.build()?;
1763    let local_var_resp = local_var_client.execute(local_var_req).await?;
1764
1765    let local_var_status = local_var_resp.status();
1766    let local_var_content = local_var_resp.text().await?;
1767
1768    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1769        serde_json::from_str(&local_var_content).map_err(Error::from)
1770    } else {
1771        let local_var_entity: Option<GetQueueElementsPostError> =
1772            serde_json::from_str(&local_var_content).ok();
1773        let local_var_error = ResponseContent {
1774            status: local_var_status,
1775            content: local_var_content,
1776            entity: local_var_entity,
1777        };
1778        Err(Error::ResponseError(local_var_error))
1779    }
1780}
1781
1782pub async fn get_transaction_with_compression_info_post(
1783    configuration: &configuration::Configuration,
1784    get_transaction_with_compression_info_post_request: models::GetTransactionWithCompressionInfoPostRequest,
1785) -> Result<
1786    models::GetTransactionWithCompressionInfoPost200Response,
1787    Error<GetTransactionWithCompressionInfoPostError>,
1788> {
1789    let local_var_configuration = configuration;
1790
1791    let local_var_client = &local_var_configuration.client;
1792
1793    let local_var_uri_str = format!(
1794        "{}/getTransactionWithCompressionInfo",
1795        local_var_configuration.base_path
1796    );
1797    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1798    let mut local_var_req_builder =
1799        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1800
1801    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1802        local_var_req_builder =
1803            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1804    }
1805    local_var_req_builder =
1806        local_var_req_builder.json(&get_transaction_with_compression_info_post_request);
1807
1808    let local_var_req = local_var_req_builder.build()?;
1809    let local_var_resp = local_var_client.execute(local_var_req).await?;
1810
1811    let local_var_status = local_var_resp.status();
1812    let local_var_content = local_var_resp.text().await?;
1813
1814    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1815        serde_json::from_str(&local_var_content).map_err(Error::from)
1816    } else {
1817        let local_var_entity: Option<GetTransactionWithCompressionInfoPostError> =
1818            serde_json::from_str(&local_var_content).ok();
1819        let local_var_error = ResponseContent {
1820            status: local_var_status,
1821            content: local_var_content,
1822            entity: local_var_entity,
1823        };
1824        Err(Error::ResponseError(local_var_error))
1825    }
1826}
1827
1828pub async fn get_transaction_with_compression_info_v2_post(
1829    configuration: &configuration::Configuration,
1830    get_transaction_with_compression_info_v2_post_request: models::GetTransactionWithCompressionInfoV2PostRequest,
1831) -> Result<
1832    models::GetTransactionWithCompressionInfoV2Post200Response,
1833    Error<GetTransactionWithCompressionInfoV2PostError>,
1834> {
1835    let local_var_configuration = configuration;
1836
1837    let local_var_client = &local_var_configuration.client;
1838
1839    let local_var_uri_str = format!(
1840        "{}/getTransactionWithCompressionInfoV2",
1841        local_var_configuration.base_path
1842    );
1843    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1844    let mut local_var_req_builder =
1845        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1846
1847    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1848        local_var_req_builder =
1849            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1850    }
1851    local_var_req_builder =
1852        local_var_req_builder.json(&get_transaction_with_compression_info_v2_post_request);
1853
1854    let local_var_req = local_var_req_builder.build()?;
1855    let local_var_resp = local_var_client.execute(local_var_req).await?;
1856
1857    let local_var_status = local_var_resp.status();
1858    let local_var_content = local_var_resp.text().await?;
1859
1860    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1861        serde_json::from_str(&local_var_content).map_err(Error::from)
1862    } else {
1863        let local_var_entity: Option<GetTransactionWithCompressionInfoV2PostError> =
1864            serde_json::from_str(&local_var_content).ok();
1865        let local_var_error = ResponseContent {
1866            status: local_var_status,
1867            content: local_var_content,
1868            entity: local_var_entity,
1869        };
1870        Err(Error::ResponseError(local_var_error))
1871    }
1872}
1873
1874pub async fn get_validity_proof_post(
1875    configuration: &configuration::Configuration,
1876    get_validity_proof_post_request: models::GetValidityProofPostRequest,
1877) -> Result<models::GetValidityProofPost200Response, Error<GetValidityProofPostError>> {
1878    let local_var_configuration = configuration;
1879
1880    let local_var_client = &local_var_configuration.client;
1881
1882    let local_var_uri_str = format!("{}/getValidityProof", local_var_configuration.base_path);
1883    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1884    let mut local_var_req_builder =
1885        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1886
1887    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1888        local_var_req_builder =
1889            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1890    }
1891    local_var_req_builder = local_var_req_builder.json(&get_validity_proof_post_request);
1892
1893    let local_var_req = local_var_req_builder.build()?;
1894    let local_var_resp = local_var_client.execute(local_var_req).await?;
1895
1896    let local_var_status = local_var_resp.status();
1897    let local_var_content = local_var_resp.text().await?;
1898
1899    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1900        serde_json::from_str(&local_var_content).map_err(Error::from)
1901    } else {
1902        let local_var_entity: Option<GetValidityProofPostError> =
1903            serde_json::from_str(&local_var_content).ok();
1904        let local_var_error = ResponseContent {
1905            status: local_var_status,
1906            content: local_var_content,
1907            entity: local_var_entity,
1908        };
1909        Err(Error::ResponseError(local_var_error))
1910    }
1911}
1912
1913pub async fn get_validity_proof_v2_post(
1914    configuration: &configuration::Configuration,
1915    get_validity_proof_v2_post_request: models::GetValidityProofV2PostRequest,
1916) -> Result<models::GetValidityProofV2Post200Response, Error<GetValidityProofV2PostError>> {
1917    let local_var_configuration = configuration;
1918
1919    let local_var_client = &local_var_configuration.client;
1920
1921    let local_var_uri_str = format!("{}/getValidityProofV2", local_var_configuration.base_path);
1922    let local_var_uri_str = append_api_key(local_var_configuration, &local_var_uri_str);
1923    let mut local_var_req_builder =
1924        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1925
1926    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1927        local_var_req_builder =
1928            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1929    }
1930    local_var_req_builder = local_var_req_builder.json(&get_validity_proof_v2_post_request);
1931
1932    let local_var_req = local_var_req_builder.build()?;
1933    let local_var_resp = local_var_client.execute(local_var_req).await?;
1934
1935    let local_var_status = local_var_resp.status();
1936    let local_var_content = local_var_resp.text().await?;
1937
1938    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1939        serde_json::from_str(&local_var_content).map_err(Error::from)
1940    } else {
1941        let local_var_entity: Option<GetValidityProofV2PostError> =
1942            serde_json::from_str(&local_var_content).ok();
1943        let local_var_error = ResponseContent {
1944            status: local_var_status,
1945            content: local_var_content,
1946            entity: local_var_entity,
1947        };
1948        Err(Error::ResponseError(local_var_error))
1949    }
1950}
1951
1952fn append_api_key(configuration: &Configuration, uri_str: &str) -> String {
1953    let mut uri_str = uri_str.to_string();
1954    if let Some(ref api_key) = configuration.api_key {
1955        let prefix = api_key.prefix.clone().unwrap_or("api-key".to_string());
1956        uri_str = format!("{}?{}={}", uri_str, prefix, api_key.key);
1957    }
1958    uri_str
1959}