Skip to main content

binance_sdk/sub_account/rest_api/apis/
managed_sub_account_api.rs

1/*
2 * Binance Sub Account REST API
3 *
4 * OpenAPI Specification for the Binance Sub Account REST API
5 *
6 * The version of the OpenAPI document: 1.0.0
7 *
8 *
9 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
10 * https://openapi-generator.tech
11 * Do not edit the class manually.
12 */
13
14#![allow(unused_imports)]
15use async_trait::async_trait;
16use derive_builder::Builder;
17use reqwest;
18use rust_decimal::prelude::*;
19use serde::{Deserialize, Serialize};
20use serde_json::{Value, json};
21use std::collections::BTreeMap;
22
23use crate::common::{
24    config::ConfigurationRestApi,
25    models::{ParamBuildError, RestApiResponse},
26    utils::send_request,
27};
28use crate::sub_account::rest_api::models;
29
30const HAS_TIME_UNIT: bool = false;
31
32#[async_trait]
33pub trait ManagedSubAccountApi: Send + Sync {
34    async fn deposit_assets_into_the_managed_sub_account(
35        &self,
36        params: DepositAssetsIntoTheManagedSubAccountParams,
37    ) -> anyhow::Result<RestApiResponse<models::DepositAssetsIntoTheManagedSubAccountResponse>>;
38    async fn get_managed_sub_account_deposit_address(
39        &self,
40        params: GetManagedSubAccountDepositAddressParams,
41    ) -> anyhow::Result<RestApiResponse<models::GetManagedSubAccountDepositAddressResponse>>;
42    async fn query_managed_sub_account_asset_details(
43        &self,
44        params: QueryManagedSubAccountAssetDetailsParams,
45    ) -> anyhow::Result<RestApiResponse<Vec<models::QueryManagedSubAccountAssetDetailsResponseInner>>>;
46    async fn query_managed_sub_account_futures_asset_details(
47        &self,
48        params: QueryManagedSubAccountFuturesAssetDetailsParams,
49    ) -> anyhow::Result<RestApiResponse<models::QueryManagedSubAccountFuturesAssetDetailsResponse>>;
50    async fn query_managed_sub_account_list(
51        &self,
52        params: QueryManagedSubAccountListParams,
53    ) -> anyhow::Result<RestApiResponse<models::QueryManagedSubAccountListResponse>>;
54    async fn query_managed_sub_account_margin_asset_details(
55        &self,
56        params: QueryManagedSubAccountMarginAssetDetailsParams,
57    ) -> anyhow::Result<RestApiResponse<models::QueryManagedSubAccountMarginAssetDetailsResponse>>;
58    async fn query_managed_sub_account_snapshot(
59        &self,
60        params: QueryManagedSubAccountSnapshotParams,
61    ) -> anyhow::Result<RestApiResponse<models::QueryManagedSubAccountSnapshotResponse>>;
62    async fn query_managed_sub_account_transfer_log_master_account_investor(
63        &self,
64        params: QueryManagedSubAccountTransferLogMasterAccountInvestorParams,
65    ) -> anyhow::Result<
66        RestApiResponse<models::QueryManagedSubAccountTransferLogMasterAccountInvestorResponse>,
67    >;
68    async fn query_managed_sub_account_transfer_log_master_account_trading(
69        &self,
70        params: QueryManagedSubAccountTransferLogMasterAccountTradingParams,
71    ) -> anyhow::Result<
72        RestApiResponse<models::QueryManagedSubAccountTransferLogMasterAccountTradingResponse>,
73    >;
74    async fn query_managed_sub_account_transfer_log_sub_account_trading(
75        &self,
76        params: QueryManagedSubAccountTransferLogSubAccountTradingParams,
77    ) -> anyhow::Result<
78        RestApiResponse<models::QueryManagedSubAccountTransferLogSubAccountTradingResponse>,
79    >;
80    async fn withdrawl_assets_from_the_managed_sub_account(
81        &self,
82        params: WithdrawlAssetsFromTheManagedSubAccountParams,
83    ) -> anyhow::Result<RestApiResponse<models::WithdrawlAssetsFromTheManagedSubAccountResponse>>;
84}
85
86#[derive(Debug, Clone)]
87pub struct ManagedSubAccountApiClient {
88    configuration: ConfigurationRestApi,
89}
90
91impl ManagedSubAccountApiClient {
92    pub fn new(configuration: ConfigurationRestApi) -> Self {
93        Self { configuration }
94    }
95}
96
97/// Request parameters for the [`deposit_assets_into_the_managed_sub_account`] operation.
98///
99/// This struct holds all of the inputs you can pass when calling
100/// [`deposit_assets_into_the_managed_sub_account`](#method.deposit_assets_into_the_managed_sub_account).
101#[derive(Clone, Debug, Builder)]
102#[builder(pattern = "owned", build_fn(error = "ParamBuildError"))]
103pub struct DepositAssetsIntoTheManagedSubAccountParams {
104    ///
105    /// The `to_email` parameter.
106    ///
107    /// This field is **required.
108    #[builder(setter(into))]
109    pub to_email: String,
110    ///
111    /// The `asset` parameter.
112    ///
113    /// This field is **required.
114    #[builder(setter(into))]
115    pub asset: String,
116    ///
117    /// The `amount` parameter.
118    ///
119    /// This field is **required.
120    #[builder(setter(into))]
121    pub amount: rust_decimal::Decimal,
122    ///
123    /// The `recv_window` parameter.
124    ///
125    /// This field is **optional.
126    #[builder(setter(into), default)]
127    pub recv_window: Option<i64>,
128}
129
130impl DepositAssetsIntoTheManagedSubAccountParams {
131    /// Create a builder for [`deposit_assets_into_the_managed_sub_account`].
132    ///
133    /// Required parameters:
134    ///
135    /// * `to_email` — String
136    /// * `asset` — String
137    /// * `amount` — `rust_decimal::Decimal`
138    ///
139    #[must_use]
140    pub fn builder(
141        to_email: String,
142        asset: String,
143        amount: rust_decimal::Decimal,
144    ) -> DepositAssetsIntoTheManagedSubAccountParamsBuilder {
145        DepositAssetsIntoTheManagedSubAccountParamsBuilder::default()
146            .to_email(to_email)
147            .asset(asset)
148            .amount(amount)
149    }
150}
151/// Request parameters for the [`get_managed_sub_account_deposit_address`] operation.
152///
153/// This struct holds all of the inputs you can pass when calling
154/// [`get_managed_sub_account_deposit_address`](#method.get_managed_sub_account_deposit_address).
155#[derive(Clone, Debug, Builder)]
156#[builder(pattern = "owned", build_fn(error = "ParamBuildError"))]
157pub struct GetManagedSubAccountDepositAddressParams {
158    /// [Sub-account email](#email-address)
159    ///
160    /// This field is **required.
161    #[builder(setter(into))]
162    pub email: String,
163    ///
164    /// The `coin` parameter.
165    ///
166    /// This field is **required.
167    #[builder(setter(into))]
168    pub coin: String,
169    /// networks can be found in `GET /sapi/v1/capital/deposit/address`
170    ///
171    /// This field is **optional.
172    #[builder(setter(into), default)]
173    pub network: Option<String>,
174    ///
175    /// The `amount` parameter.
176    ///
177    /// This field is **optional.
178    #[builder(setter(into), default)]
179    pub amount: Option<rust_decimal::Decimal>,
180    ///
181    /// The `recv_window` parameter.
182    ///
183    /// This field is **optional.
184    #[builder(setter(into), default)]
185    pub recv_window: Option<i64>,
186}
187
188impl GetManagedSubAccountDepositAddressParams {
189    /// Create a builder for [`get_managed_sub_account_deposit_address`].
190    ///
191    /// Required parameters:
192    ///
193    /// * `email` — [Sub-account email](#email-address)
194    /// * `coin` — String
195    ///
196    #[must_use]
197    pub fn builder(email: String, coin: String) -> GetManagedSubAccountDepositAddressParamsBuilder {
198        GetManagedSubAccountDepositAddressParamsBuilder::default()
199            .email(email)
200            .coin(coin)
201    }
202}
203/// Request parameters for the [`query_managed_sub_account_asset_details`] operation.
204///
205/// This struct holds all of the inputs you can pass when calling
206/// [`query_managed_sub_account_asset_details`](#method.query_managed_sub_account_asset_details).
207#[derive(Clone, Debug, Builder)]
208#[builder(pattern = "owned", build_fn(error = "ParamBuildError"))]
209pub struct QueryManagedSubAccountAssetDetailsParams {
210    /// [Sub-account email](#email-address)
211    ///
212    /// This field is **required.
213    #[builder(setter(into))]
214    pub email: String,
215    ///
216    /// The `recv_window` parameter.
217    ///
218    /// This field is **optional.
219    #[builder(setter(into), default)]
220    pub recv_window: Option<i64>,
221}
222
223impl QueryManagedSubAccountAssetDetailsParams {
224    /// Create a builder for [`query_managed_sub_account_asset_details`].
225    ///
226    /// Required parameters:
227    ///
228    /// * `email` — [Sub-account email](#email-address)
229    ///
230    #[must_use]
231    pub fn builder(email: String) -> QueryManagedSubAccountAssetDetailsParamsBuilder {
232        QueryManagedSubAccountAssetDetailsParamsBuilder::default().email(email)
233    }
234}
235/// Request parameters for the [`query_managed_sub_account_futures_asset_details`] operation.
236///
237/// This struct holds all of the inputs you can pass when calling
238/// [`query_managed_sub_account_futures_asset_details`](#method.query_managed_sub_account_futures_asset_details).
239#[derive(Clone, Debug, Builder)]
240#[builder(pattern = "owned", build_fn(error = "ParamBuildError"))]
241pub struct QueryManagedSubAccountFuturesAssetDetailsParams {
242    /// [Sub-account email](#email-address)
243    ///
244    /// This field is **required.
245    #[builder(setter(into))]
246    pub email: String,
247    /// No input or input "MARGIN" to get Cross Margin account details. Input "`ISOLATED_MARGIN`" to get Isolated Margin account details.
248    ///
249    /// This field is **optional.
250    #[builder(setter(into), default)]
251    pub account_type: Option<String>,
252}
253
254impl QueryManagedSubAccountFuturesAssetDetailsParams {
255    /// Create a builder for [`query_managed_sub_account_futures_asset_details`].
256    ///
257    /// Required parameters:
258    ///
259    /// * `email` — [Sub-account email](#email-address)
260    ///
261    #[must_use]
262    pub fn builder(email: String) -> QueryManagedSubAccountFuturesAssetDetailsParamsBuilder {
263        QueryManagedSubAccountFuturesAssetDetailsParamsBuilder::default().email(email)
264    }
265}
266/// Request parameters for the [`query_managed_sub_account_list`] operation.
267///
268/// This struct holds all of the inputs you can pass when calling
269/// [`query_managed_sub_account_list`](#method.query_managed_sub_account_list).
270#[derive(Clone, Debug, Builder, Default)]
271#[builder(pattern = "owned", build_fn(error = "ParamBuildError"))]
272pub struct QueryManagedSubAccountListParams {
273    /// Managed sub-account email
274    ///
275    /// This field is **optional.
276    #[builder(setter(into), default)]
277    pub email: Option<String>,
278    /// Default value: 1
279    ///
280    /// This field is **optional.
281    #[builder(setter(into), default)]
282    pub page: Option<i64>,
283    /// Default value: 1, Max value: 200
284    ///
285    /// This field is **optional.
286    #[builder(setter(into), default)]
287    pub limit: Option<i64>,
288    ///
289    /// The `recv_window` parameter.
290    ///
291    /// This field is **optional.
292    #[builder(setter(into), default)]
293    pub recv_window: Option<i64>,
294}
295
296impl QueryManagedSubAccountListParams {
297    /// Create a builder for [`query_managed_sub_account_list`].
298    ///
299    #[must_use]
300    pub fn builder() -> QueryManagedSubAccountListParamsBuilder {
301        QueryManagedSubAccountListParamsBuilder::default()
302    }
303}
304/// Request parameters for the [`query_managed_sub_account_margin_asset_details`] operation.
305///
306/// This struct holds all of the inputs you can pass when calling
307/// [`query_managed_sub_account_margin_asset_details`](#method.query_managed_sub_account_margin_asset_details).
308#[derive(Clone, Debug, Builder)]
309#[builder(pattern = "owned", build_fn(error = "ParamBuildError"))]
310pub struct QueryManagedSubAccountMarginAssetDetailsParams {
311    /// [Sub-account email](#email-address)
312    ///
313    /// This field is **required.
314    #[builder(setter(into))]
315    pub email: String,
316    /// No input or input "MARGIN" to get Cross Margin account details. Input "`ISOLATED_MARGIN`" to get Isolated Margin account details.
317    ///
318    /// This field is **optional.
319    #[builder(setter(into), default)]
320    pub account_type: Option<String>,
321}
322
323impl QueryManagedSubAccountMarginAssetDetailsParams {
324    /// Create a builder for [`query_managed_sub_account_margin_asset_details`].
325    ///
326    /// Required parameters:
327    ///
328    /// * `email` — [Sub-account email](#email-address)
329    ///
330    #[must_use]
331    pub fn builder(email: String) -> QueryManagedSubAccountMarginAssetDetailsParamsBuilder {
332        QueryManagedSubAccountMarginAssetDetailsParamsBuilder::default().email(email)
333    }
334}
335/// Request parameters for the [`query_managed_sub_account_snapshot`] operation.
336///
337/// This struct holds all of the inputs you can pass when calling
338/// [`query_managed_sub_account_snapshot`](#method.query_managed_sub_account_snapshot).
339#[derive(Clone, Debug, Builder)]
340#[builder(pattern = "owned", build_fn(error = "ParamBuildError"))]
341pub struct QueryManagedSubAccountSnapshotParams {
342    /// [Sub-account email](#email-address)
343    ///
344    /// This field is **required.
345    #[builder(setter(into))]
346    pub email: String,
347    /// "SPOT", "MARGIN"（cross）, "FUTURES"（UM）
348    ///
349    /// This field is **required.
350    #[builder(setter(into))]
351    pub r#type: String,
352    ///
353    /// The `start_time` parameter.
354    ///
355    /// This field is **optional.
356    #[builder(setter(into), default)]
357    pub start_time: Option<i64>,
358    ///
359    /// The `end_time` parameter.
360    ///
361    /// This field is **optional.
362    #[builder(setter(into), default)]
363    pub end_time: Option<i64>,
364    /// Default value: 1, Max value: 200
365    ///
366    /// This field is **optional.
367    #[builder(setter(into), default)]
368    pub limit: Option<i64>,
369    ///
370    /// The `recv_window` parameter.
371    ///
372    /// This field is **optional.
373    #[builder(setter(into), default)]
374    pub recv_window: Option<i64>,
375}
376
377impl QueryManagedSubAccountSnapshotParams {
378    /// Create a builder for [`query_managed_sub_account_snapshot`].
379    ///
380    /// Required parameters:
381    ///
382    /// * `email` — [Sub-account email](#email-address)
383    /// * `r#type` — \"SPOT\", \"MARGIN\"（cross）, \"FUTURES\"（UM）
384    ///
385    #[must_use]
386    pub fn builder(email: String, r#type: String) -> QueryManagedSubAccountSnapshotParamsBuilder {
387        QueryManagedSubAccountSnapshotParamsBuilder::default()
388            .email(email)
389            .r#type(r#type)
390    }
391}
392/// Request parameters for the [`query_managed_sub_account_transfer_log_master_account_investor`] operation.
393///
394/// This struct holds all of the inputs you can pass when calling
395/// [`query_managed_sub_account_transfer_log_master_account_investor`](#method.query_managed_sub_account_transfer_log_master_account_investor).
396#[derive(Clone, Debug, Builder)]
397#[builder(pattern = "owned", build_fn(error = "ParamBuildError"))]
398pub struct QueryManagedSubAccountTransferLogMasterAccountInvestorParams {
399    /// [Sub-account email](#email-address)
400    ///
401    /// This field is **required.
402    #[builder(setter(into))]
403    pub email: String,
404    /// Start Time
405    ///
406    /// This field is **required.
407    #[builder(setter(into))]
408    pub start_time: i64,
409    /// End Time (The start time and end time interval cannot exceed half a year)
410    ///
411    /// This field is **required.
412    #[builder(setter(into))]
413    pub end_time: i64,
414    /// Page
415    ///
416    /// This field is **required.
417    #[builder(setter(into))]
418    pub page: i64,
419    /// Limit (Max: 500)
420    ///
421    /// This field is **required.
422    #[builder(setter(into))]
423    pub limit: i64,
424    /// Transfer Direction (from/to)
425    ///
426    /// This field is **optional.
427    #[builder(setter(into), default)]
428    pub transfers: Option<String>,
429    /// Transfer function account type (`SPOT/MARGIN/ISOLATED_MARGIN/USDT_FUTURE/COIN_FUTURE`)
430    ///
431    /// This field is **optional.
432    #[builder(setter(into), default)]
433    pub transfer_function_account_type: Option<String>,
434}
435
436impl QueryManagedSubAccountTransferLogMasterAccountInvestorParams {
437    /// Create a builder for [`query_managed_sub_account_transfer_log_master_account_investor`].
438    ///
439    /// Required parameters:
440    ///
441    /// * `email` — [Sub-account email](#email-address)
442    /// * `start_time` — Start Time
443    /// * `end_time` — End Time (The start time and end time interval cannot exceed half a year)
444    /// * `page` — Page
445    /// * `limit` — Limit (Max: 500)
446    ///
447    #[must_use]
448    pub fn builder(
449        email: String,
450        start_time: i64,
451        end_time: i64,
452        page: i64,
453        limit: i64,
454    ) -> QueryManagedSubAccountTransferLogMasterAccountInvestorParamsBuilder {
455        QueryManagedSubAccountTransferLogMasterAccountInvestorParamsBuilder::default()
456            .email(email)
457            .start_time(start_time)
458            .end_time(end_time)
459            .page(page)
460            .limit(limit)
461    }
462}
463/// Request parameters for the [`query_managed_sub_account_transfer_log_master_account_trading`] operation.
464///
465/// This struct holds all of the inputs you can pass when calling
466/// [`query_managed_sub_account_transfer_log_master_account_trading`](#method.query_managed_sub_account_transfer_log_master_account_trading).
467#[derive(Clone, Debug, Builder)]
468#[builder(pattern = "owned", build_fn(error = "ParamBuildError"))]
469pub struct QueryManagedSubAccountTransferLogMasterAccountTradingParams {
470    /// [Sub-account email](#email-address)
471    ///
472    /// This field is **required.
473    #[builder(setter(into))]
474    pub email: String,
475    /// Start Time
476    ///
477    /// This field is **required.
478    #[builder(setter(into))]
479    pub start_time: i64,
480    /// End Time (The start time and end time interval cannot exceed half a year)
481    ///
482    /// This field is **required.
483    #[builder(setter(into))]
484    pub end_time: i64,
485    /// Page
486    ///
487    /// This field is **required.
488    #[builder(setter(into))]
489    pub page: i64,
490    /// Limit (Max: 500)
491    ///
492    /// This field is **required.
493    #[builder(setter(into))]
494    pub limit: i64,
495    /// Transfer Direction (from/to)
496    ///
497    /// This field is **optional.
498    #[builder(setter(into), default)]
499    pub transfers: Option<String>,
500    /// Transfer function account type (`SPOT/MARGIN/ISOLATED_MARGIN/USDT_FUTURE/COIN_FUTURE`)
501    ///
502    /// This field is **optional.
503    #[builder(setter(into), default)]
504    pub transfer_function_account_type: Option<String>,
505}
506
507impl QueryManagedSubAccountTransferLogMasterAccountTradingParams {
508    /// Create a builder for [`query_managed_sub_account_transfer_log_master_account_trading`].
509    ///
510    /// Required parameters:
511    ///
512    /// * `email` — [Sub-account email](#email-address)
513    /// * `start_time` — Start Time
514    /// * `end_time` — End Time (The start time and end time interval cannot exceed half a year)
515    /// * `page` — Page
516    /// * `limit` — Limit (Max: 500)
517    ///
518    #[must_use]
519    pub fn builder(
520        email: String,
521        start_time: i64,
522        end_time: i64,
523        page: i64,
524        limit: i64,
525    ) -> QueryManagedSubAccountTransferLogMasterAccountTradingParamsBuilder {
526        QueryManagedSubAccountTransferLogMasterAccountTradingParamsBuilder::default()
527            .email(email)
528            .start_time(start_time)
529            .end_time(end_time)
530            .page(page)
531            .limit(limit)
532    }
533}
534/// Request parameters for the [`query_managed_sub_account_transfer_log_sub_account_trading`] operation.
535///
536/// This struct holds all of the inputs you can pass when calling
537/// [`query_managed_sub_account_transfer_log_sub_account_trading`](#method.query_managed_sub_account_transfer_log_sub_account_trading).
538#[derive(Clone, Debug, Builder)]
539#[builder(pattern = "owned", build_fn(error = "ParamBuildError"))]
540pub struct QueryManagedSubAccountTransferLogSubAccountTradingParams {
541    /// Start Time
542    ///
543    /// This field is **required.
544    #[builder(setter(into))]
545    pub start_time: i64,
546    /// End Time (The start time and end time interval cannot exceed half a year)
547    ///
548    /// This field is **required.
549    #[builder(setter(into))]
550    pub end_time: i64,
551    /// Page
552    ///
553    /// This field is **required.
554    #[builder(setter(into))]
555    pub page: i64,
556    /// Limit (Max: 500)
557    ///
558    /// This field is **required.
559    #[builder(setter(into))]
560    pub limit: i64,
561    /// Transfer Direction (from/to)
562    ///
563    /// This field is **optional.
564    #[builder(setter(into), default)]
565    pub transfers: Option<String>,
566    /// Transfer function account type (`SPOT/MARGIN/ISOLATED_MARGIN/USDT_FUTURE/COIN_FUTURE`)
567    ///
568    /// This field is **optional.
569    #[builder(setter(into), default)]
570    pub transfer_function_account_type: Option<String>,
571    ///
572    /// The `recv_window` parameter.
573    ///
574    /// This field is **optional.
575    #[builder(setter(into), default)]
576    pub recv_window: Option<i64>,
577}
578
579impl QueryManagedSubAccountTransferLogSubAccountTradingParams {
580    /// Create a builder for [`query_managed_sub_account_transfer_log_sub_account_trading`].
581    ///
582    /// Required parameters:
583    ///
584    /// * `start_time` — Start Time
585    /// * `end_time` — End Time (The start time and end time interval cannot exceed half a year)
586    /// * `page` — Page
587    /// * `limit` — Limit (Max: 500)
588    ///
589    #[must_use]
590    pub fn builder(
591        start_time: i64,
592        end_time: i64,
593        page: i64,
594        limit: i64,
595    ) -> QueryManagedSubAccountTransferLogSubAccountTradingParamsBuilder {
596        QueryManagedSubAccountTransferLogSubAccountTradingParamsBuilder::default()
597            .start_time(start_time)
598            .end_time(end_time)
599            .page(page)
600            .limit(limit)
601    }
602}
603/// Request parameters for the [`withdrawl_assets_from_the_managed_sub_account`] operation.
604///
605/// This struct holds all of the inputs you can pass when calling
606/// [`withdrawl_assets_from_the_managed_sub_account`](#method.withdrawl_assets_from_the_managed_sub_account).
607#[derive(Clone, Debug, Builder)]
608#[builder(pattern = "owned", build_fn(error = "ParamBuildError"))]
609pub struct WithdrawlAssetsFromTheManagedSubAccountParams {
610    ///
611    /// The `from_email` parameter.
612    ///
613    /// This field is **required.
614    #[builder(setter(into))]
615    pub from_email: String,
616    ///
617    /// The `asset` parameter.
618    ///
619    /// This field is **required.
620    #[builder(setter(into))]
621    pub asset: String,
622    ///
623    /// The `amount` parameter.
624    ///
625    /// This field is **required.
626    #[builder(setter(into))]
627    pub amount: rust_decimal::Decimal,
628    /// Withdrawals is automatically occur on the transfer date(UTC0). If a date is not selected, the withdrawal occurs right now
629    ///
630    /// This field is **optional.
631    #[builder(setter(into), default)]
632    pub transfer_date: Option<i64>,
633    ///
634    /// The `recv_window` parameter.
635    ///
636    /// This field is **optional.
637    #[builder(setter(into), default)]
638    pub recv_window: Option<i64>,
639}
640
641impl WithdrawlAssetsFromTheManagedSubAccountParams {
642    /// Create a builder for [`withdrawl_assets_from_the_managed_sub_account`].
643    ///
644    /// Required parameters:
645    ///
646    /// * `from_email` — String
647    /// * `asset` — String
648    /// * `amount` — `rust_decimal::Decimal`
649    ///
650    #[must_use]
651    pub fn builder(
652        from_email: String,
653        asset: String,
654        amount: rust_decimal::Decimal,
655    ) -> WithdrawlAssetsFromTheManagedSubAccountParamsBuilder {
656        WithdrawlAssetsFromTheManagedSubAccountParamsBuilder::default()
657            .from_email(from_email)
658            .asset(asset)
659            .amount(amount)
660    }
661}
662
663#[async_trait]
664impl ManagedSubAccountApi for ManagedSubAccountApiClient {
665    async fn deposit_assets_into_the_managed_sub_account(
666        &self,
667        params: DepositAssetsIntoTheManagedSubAccountParams,
668    ) -> anyhow::Result<RestApiResponse<models::DepositAssetsIntoTheManagedSubAccountResponse>>
669    {
670        let DepositAssetsIntoTheManagedSubAccountParams {
671            to_email,
672            asset,
673            amount,
674            recv_window,
675        } = params;
676
677        let mut query_params = BTreeMap::new();
678        let body_params = BTreeMap::new();
679
680        query_params.insert("toEmail".to_string(), json!(to_email));
681
682        query_params.insert("asset".to_string(), json!(asset));
683
684        query_params.insert("amount".to_string(), json!(amount));
685
686        if let Some(rw) = recv_window {
687            query_params.insert("recvWindow".to_string(), json!(rw));
688        }
689
690        send_request::<models::DepositAssetsIntoTheManagedSubAccountResponse>(
691            &self.configuration,
692            "/sapi/v1/managed-subaccount/deposit",
693            reqwest::Method::POST,
694            query_params,
695            body_params,
696            if HAS_TIME_UNIT {
697                self.configuration.time_unit
698            } else {
699                None
700            },
701            true,
702        )
703        .await
704    }
705
706    async fn get_managed_sub_account_deposit_address(
707        &self,
708        params: GetManagedSubAccountDepositAddressParams,
709    ) -> anyhow::Result<RestApiResponse<models::GetManagedSubAccountDepositAddressResponse>> {
710        let GetManagedSubAccountDepositAddressParams {
711            email,
712            coin,
713            network,
714            amount,
715            recv_window,
716        } = params;
717
718        let mut query_params = BTreeMap::new();
719        let body_params = BTreeMap::new();
720
721        query_params.insert("email".to_string(), json!(email));
722
723        query_params.insert("coin".to_string(), json!(coin));
724
725        if let Some(rw) = network {
726            query_params.insert("network".to_string(), json!(rw));
727        }
728
729        if let Some(rw) = amount {
730            query_params.insert("amount".to_string(), json!(rw));
731        }
732
733        if let Some(rw) = recv_window {
734            query_params.insert("recvWindow".to_string(), json!(rw));
735        }
736
737        send_request::<models::GetManagedSubAccountDepositAddressResponse>(
738            &self.configuration,
739            "/sapi/v1/managed-subaccount/deposit/address",
740            reqwest::Method::GET,
741            query_params,
742            body_params,
743            if HAS_TIME_UNIT {
744                self.configuration.time_unit
745            } else {
746                None
747            },
748            true,
749        )
750        .await
751    }
752
753    async fn query_managed_sub_account_asset_details(
754        &self,
755        params: QueryManagedSubAccountAssetDetailsParams,
756    ) -> anyhow::Result<RestApiResponse<Vec<models::QueryManagedSubAccountAssetDetailsResponseInner>>>
757    {
758        let QueryManagedSubAccountAssetDetailsParams { email, recv_window } = params;
759
760        let mut query_params = BTreeMap::new();
761        let body_params = BTreeMap::new();
762
763        query_params.insert("email".to_string(), json!(email));
764
765        if let Some(rw) = recv_window {
766            query_params.insert("recvWindow".to_string(), json!(rw));
767        }
768
769        send_request::<Vec<models::QueryManagedSubAccountAssetDetailsResponseInner>>(
770            &self.configuration,
771            "/sapi/v1/managed-subaccount/asset",
772            reqwest::Method::GET,
773            query_params,
774            body_params,
775            if HAS_TIME_UNIT {
776                self.configuration.time_unit
777            } else {
778                None
779            },
780            true,
781        )
782        .await
783    }
784
785    async fn query_managed_sub_account_futures_asset_details(
786        &self,
787        params: QueryManagedSubAccountFuturesAssetDetailsParams,
788    ) -> anyhow::Result<RestApiResponse<models::QueryManagedSubAccountFuturesAssetDetailsResponse>>
789    {
790        let QueryManagedSubAccountFuturesAssetDetailsParams {
791            email,
792            account_type,
793        } = params;
794
795        let mut query_params = BTreeMap::new();
796        let body_params = BTreeMap::new();
797
798        query_params.insert("email".to_string(), json!(email));
799
800        if let Some(rw) = account_type {
801            query_params.insert("accountType".to_string(), json!(rw));
802        }
803
804        send_request::<models::QueryManagedSubAccountFuturesAssetDetailsResponse>(
805            &self.configuration,
806            "/sapi/v1/managed-subaccount/fetch-future-asset",
807            reqwest::Method::GET,
808            query_params,
809            body_params,
810            if HAS_TIME_UNIT {
811                self.configuration.time_unit
812            } else {
813                None
814            },
815            true,
816        )
817        .await
818    }
819
820    async fn query_managed_sub_account_list(
821        &self,
822        params: QueryManagedSubAccountListParams,
823    ) -> anyhow::Result<RestApiResponse<models::QueryManagedSubAccountListResponse>> {
824        let QueryManagedSubAccountListParams {
825            email,
826            page,
827            limit,
828            recv_window,
829        } = params;
830
831        let mut query_params = BTreeMap::new();
832        let body_params = BTreeMap::new();
833
834        if let Some(rw) = email {
835            query_params.insert("email".to_string(), json!(rw));
836        }
837
838        if let Some(rw) = page {
839            query_params.insert("page".to_string(), json!(rw));
840        }
841
842        if let Some(rw) = limit {
843            query_params.insert("limit".to_string(), json!(rw));
844        }
845
846        if let Some(rw) = recv_window {
847            query_params.insert("recvWindow".to_string(), json!(rw));
848        }
849
850        send_request::<models::QueryManagedSubAccountListResponse>(
851            &self.configuration,
852            "/sapi/v1/managed-subaccount/info",
853            reqwest::Method::GET,
854            query_params,
855            body_params,
856            if HAS_TIME_UNIT {
857                self.configuration.time_unit
858            } else {
859                None
860            },
861            true,
862        )
863        .await
864    }
865
866    async fn query_managed_sub_account_margin_asset_details(
867        &self,
868        params: QueryManagedSubAccountMarginAssetDetailsParams,
869    ) -> anyhow::Result<RestApiResponse<models::QueryManagedSubAccountMarginAssetDetailsResponse>>
870    {
871        let QueryManagedSubAccountMarginAssetDetailsParams {
872            email,
873            account_type,
874        } = params;
875
876        let mut query_params = BTreeMap::new();
877        let body_params = BTreeMap::new();
878
879        query_params.insert("email".to_string(), json!(email));
880
881        if let Some(rw) = account_type {
882            query_params.insert("accountType".to_string(), json!(rw));
883        }
884
885        send_request::<models::QueryManagedSubAccountMarginAssetDetailsResponse>(
886            &self.configuration,
887            "/sapi/v1/managed-subaccount/marginAsset",
888            reqwest::Method::GET,
889            query_params,
890            body_params,
891            if HAS_TIME_UNIT {
892                self.configuration.time_unit
893            } else {
894                None
895            },
896            true,
897        )
898        .await
899    }
900
901    async fn query_managed_sub_account_snapshot(
902        &self,
903        params: QueryManagedSubAccountSnapshotParams,
904    ) -> anyhow::Result<RestApiResponse<models::QueryManagedSubAccountSnapshotResponse>> {
905        let QueryManagedSubAccountSnapshotParams {
906            email,
907            r#type,
908            start_time,
909            end_time,
910            limit,
911            recv_window,
912        } = params;
913
914        let mut query_params = BTreeMap::new();
915        let body_params = BTreeMap::new();
916
917        query_params.insert("email".to_string(), json!(email));
918
919        query_params.insert("type".to_string(), json!(r#type));
920
921        if let Some(rw) = start_time {
922            query_params.insert("startTime".to_string(), json!(rw));
923        }
924
925        if let Some(rw) = end_time {
926            query_params.insert("endTime".to_string(), json!(rw));
927        }
928
929        if let Some(rw) = limit {
930            query_params.insert("limit".to_string(), json!(rw));
931        }
932
933        if let Some(rw) = recv_window {
934            query_params.insert("recvWindow".to_string(), json!(rw));
935        }
936
937        send_request::<models::QueryManagedSubAccountSnapshotResponse>(
938            &self.configuration,
939            "/sapi/v1/managed-subaccount/accountSnapshot",
940            reqwest::Method::GET,
941            query_params,
942            body_params,
943            if HAS_TIME_UNIT {
944                self.configuration.time_unit
945            } else {
946                None
947            },
948            true,
949        )
950        .await
951    }
952
953    async fn query_managed_sub_account_transfer_log_master_account_investor(
954        &self,
955        params: QueryManagedSubAccountTransferLogMasterAccountInvestorParams,
956    ) -> anyhow::Result<
957        RestApiResponse<models::QueryManagedSubAccountTransferLogMasterAccountInvestorResponse>,
958    > {
959        let QueryManagedSubAccountTransferLogMasterAccountInvestorParams {
960            email,
961            start_time,
962            end_time,
963            page,
964            limit,
965            transfers,
966            transfer_function_account_type,
967        } = params;
968
969        let mut query_params = BTreeMap::new();
970        let body_params = BTreeMap::new();
971
972        query_params.insert("email".to_string(), json!(email));
973
974        query_params.insert("startTime".to_string(), json!(start_time));
975
976        query_params.insert("endTime".to_string(), json!(end_time));
977
978        query_params.insert("page".to_string(), json!(page));
979
980        query_params.insert("limit".to_string(), json!(limit));
981
982        if let Some(rw) = transfers {
983            query_params.insert("transfers".to_string(), json!(rw));
984        }
985
986        if let Some(rw) = transfer_function_account_type {
987            query_params.insert("transferFunctionAccountType".to_string(), json!(rw));
988        }
989
990        send_request::<models::QueryManagedSubAccountTransferLogMasterAccountInvestorResponse>(
991            &self.configuration,
992            "/sapi/v1/managed-subaccount/queryTransLogForInvestor",
993            reqwest::Method::GET,
994            query_params,
995            body_params,
996            if HAS_TIME_UNIT {
997                self.configuration.time_unit
998            } else {
999                None
1000            },
1001            true,
1002        )
1003        .await
1004    }
1005
1006    async fn query_managed_sub_account_transfer_log_master_account_trading(
1007        &self,
1008        params: QueryManagedSubAccountTransferLogMasterAccountTradingParams,
1009    ) -> anyhow::Result<
1010        RestApiResponse<models::QueryManagedSubAccountTransferLogMasterAccountTradingResponse>,
1011    > {
1012        let QueryManagedSubAccountTransferLogMasterAccountTradingParams {
1013            email,
1014            start_time,
1015            end_time,
1016            page,
1017            limit,
1018            transfers,
1019            transfer_function_account_type,
1020        } = params;
1021
1022        let mut query_params = BTreeMap::new();
1023        let body_params = BTreeMap::new();
1024
1025        query_params.insert("email".to_string(), json!(email));
1026
1027        query_params.insert("startTime".to_string(), json!(start_time));
1028
1029        query_params.insert("endTime".to_string(), json!(end_time));
1030
1031        query_params.insert("page".to_string(), json!(page));
1032
1033        query_params.insert("limit".to_string(), json!(limit));
1034
1035        if let Some(rw) = transfers {
1036            query_params.insert("transfers".to_string(), json!(rw));
1037        }
1038
1039        if let Some(rw) = transfer_function_account_type {
1040            query_params.insert("transferFunctionAccountType".to_string(), json!(rw));
1041        }
1042
1043        send_request::<models::QueryManagedSubAccountTransferLogMasterAccountTradingResponse>(
1044            &self.configuration,
1045            "/sapi/v1/managed-subaccount/queryTransLogForTradeParent",
1046            reqwest::Method::GET,
1047            query_params,
1048            body_params,
1049            if HAS_TIME_UNIT {
1050                self.configuration.time_unit
1051            } else {
1052                None
1053            },
1054            true,
1055        )
1056        .await
1057    }
1058
1059    async fn query_managed_sub_account_transfer_log_sub_account_trading(
1060        &self,
1061        params: QueryManagedSubAccountTransferLogSubAccountTradingParams,
1062    ) -> anyhow::Result<
1063        RestApiResponse<models::QueryManagedSubAccountTransferLogSubAccountTradingResponse>,
1064    > {
1065        let QueryManagedSubAccountTransferLogSubAccountTradingParams {
1066            start_time,
1067            end_time,
1068            page,
1069            limit,
1070            transfers,
1071            transfer_function_account_type,
1072            recv_window,
1073        } = params;
1074
1075        let mut query_params = BTreeMap::new();
1076        let body_params = BTreeMap::new();
1077
1078        query_params.insert("startTime".to_string(), json!(start_time));
1079
1080        query_params.insert("endTime".to_string(), json!(end_time));
1081
1082        query_params.insert("page".to_string(), json!(page));
1083
1084        query_params.insert("limit".to_string(), json!(limit));
1085
1086        if let Some(rw) = transfers {
1087            query_params.insert("transfers".to_string(), json!(rw));
1088        }
1089
1090        if let Some(rw) = transfer_function_account_type {
1091            query_params.insert("transferFunctionAccountType".to_string(), json!(rw));
1092        }
1093
1094        if let Some(rw) = recv_window {
1095            query_params.insert("recvWindow".to_string(), json!(rw));
1096        }
1097
1098        send_request::<models::QueryManagedSubAccountTransferLogSubAccountTradingResponse>(
1099            &self.configuration,
1100            "/sapi/v1/managed-subaccount/query-trans-log",
1101            reqwest::Method::GET,
1102            query_params,
1103            body_params,
1104            if HAS_TIME_UNIT {
1105                self.configuration.time_unit
1106            } else {
1107                None
1108            },
1109            true,
1110        )
1111        .await
1112    }
1113
1114    async fn withdrawl_assets_from_the_managed_sub_account(
1115        &self,
1116        params: WithdrawlAssetsFromTheManagedSubAccountParams,
1117    ) -> anyhow::Result<RestApiResponse<models::WithdrawlAssetsFromTheManagedSubAccountResponse>>
1118    {
1119        let WithdrawlAssetsFromTheManagedSubAccountParams {
1120            from_email,
1121            asset,
1122            amount,
1123            transfer_date,
1124            recv_window,
1125        } = params;
1126
1127        let mut query_params = BTreeMap::new();
1128        let body_params = BTreeMap::new();
1129
1130        query_params.insert("fromEmail".to_string(), json!(from_email));
1131
1132        query_params.insert("asset".to_string(), json!(asset));
1133
1134        query_params.insert("amount".to_string(), json!(amount));
1135
1136        if let Some(rw) = transfer_date {
1137            query_params.insert("transferDate".to_string(), json!(rw));
1138        }
1139
1140        if let Some(rw) = recv_window {
1141            query_params.insert("recvWindow".to_string(), json!(rw));
1142        }
1143
1144        send_request::<models::WithdrawlAssetsFromTheManagedSubAccountResponse>(
1145            &self.configuration,
1146            "/sapi/v1/managed-subaccount/withdraw",
1147            reqwest::Method::POST,
1148            query_params,
1149            body_params,
1150            if HAS_TIME_UNIT {
1151                self.configuration.time_unit
1152            } else {
1153                None
1154            },
1155            true,
1156        )
1157        .await
1158    }
1159}
1160
1161#[cfg(all(test, feature = "sub_account"))]
1162mod tests {
1163    use super::*;
1164    use crate::TOKIO_SHARED_RT;
1165    use crate::{errors::ConnectorError, models::DataFuture, models::RestApiRateLimit};
1166    use async_trait::async_trait;
1167    use std::collections::HashMap;
1168
1169    struct DummyRestApiResponse<T> {
1170        inner: Box<dyn FnOnce() -> DataFuture<Result<T, ConnectorError>> + Send + Sync>,
1171        status: u16,
1172        headers: HashMap<String, String>,
1173        rate_limits: Option<Vec<RestApiRateLimit>>,
1174    }
1175
1176    impl<T> From<DummyRestApiResponse<T>> for RestApiResponse<T> {
1177        fn from(dummy: DummyRestApiResponse<T>) -> Self {
1178            Self {
1179                data_fn: dummy.inner,
1180                status: dummy.status,
1181                headers: dummy.headers,
1182                rate_limits: dummy.rate_limits,
1183            }
1184        }
1185    }
1186
1187    struct MockManagedSubAccountApiClient {
1188        force_error: bool,
1189    }
1190
1191    #[async_trait]
1192    impl ManagedSubAccountApi for MockManagedSubAccountApiClient {
1193        async fn deposit_assets_into_the_managed_sub_account(
1194            &self,
1195            _params: DepositAssetsIntoTheManagedSubAccountParams,
1196        ) -> anyhow::Result<RestApiResponse<models::DepositAssetsIntoTheManagedSubAccountResponse>>
1197        {
1198            if self.force_error {
1199                return Err(ConnectorError::ConnectorClientError {
1200                    msg: "ResponseError".to_string(),
1201                    code: None,
1202                }
1203                .into());
1204            }
1205
1206            let resp_json: Value = serde_json::from_str(r#"{"tranId":66157362489}"#).unwrap();
1207            let dummy_response: models::DepositAssetsIntoTheManagedSubAccountResponse =
1208                serde_json::from_value(resp_json.clone()).expect(
1209                    "should parse into models::DepositAssetsIntoTheManagedSubAccountResponse",
1210                );
1211
1212            let dummy = DummyRestApiResponse {
1213                inner: Box::new(move || Box::pin(async move { Ok(dummy_response) })),
1214                status: 200,
1215                headers: HashMap::new(),
1216                rate_limits: None,
1217            };
1218
1219            Ok(dummy.into())
1220        }
1221
1222        async fn get_managed_sub_account_deposit_address(
1223            &self,
1224            _params: GetManagedSubAccountDepositAddressParams,
1225        ) -> anyhow::Result<RestApiResponse<models::GetManagedSubAccountDepositAddressResponse>>
1226        {
1227            if self.force_error {
1228                return Err(ConnectorError::ConnectorClientError {
1229                    msg: "ResponseError".to_string(),
1230                    code: None,
1231                }
1232                .into());
1233            }
1234
1235            let resp_json: Value = serde_json::from_str(r#"{"coin":"USDT","address":"0x206c22d833bb0bb2102da6b7c7d4c3eb14bcf73d","tag":"","url":"https://etherscan.io/address/0x206c22d833bb0bb2102da6b7c7d4c3eb14bcf73d"}"#).unwrap();
1236            let dummy_response: models::GetManagedSubAccountDepositAddressResponse =
1237                serde_json::from_value(resp_json.clone())
1238                    .expect("should parse into models::GetManagedSubAccountDepositAddressResponse");
1239
1240            let dummy = DummyRestApiResponse {
1241                inner: Box::new(move || Box::pin(async move { Ok(dummy_response) })),
1242                status: 200,
1243                headers: HashMap::new(),
1244                rate_limits: None,
1245            };
1246
1247            Ok(dummy.into())
1248        }
1249
1250        async fn query_managed_sub_account_asset_details(
1251            &self,
1252            _params: QueryManagedSubAccountAssetDetailsParams,
1253        ) -> anyhow::Result<
1254            RestApiResponse<Vec<models::QueryManagedSubAccountAssetDetailsResponseInner>>,
1255        > {
1256            if self.force_error {
1257                return Err(ConnectorError::ConnectorClientError {
1258                    msg: "ResponseError".to_string(),
1259                    code: None,
1260                }
1261                .into());
1262            }
1263
1264            let resp_json: Value = serde_json::from_str(r#"[{"coin":"INJ","name":"Injective Protocol","totalBalance":"0","availableBalance":"0","inOrder":"0","btcValue":"0"},{"coin":"FILDOWN","name":"FILDOWN","totalBalance":"0","availableBalance":"0","inOrder":"0","btcValue":"0"}]"#).unwrap();
1265            let dummy_response : Vec<models::QueryManagedSubAccountAssetDetailsResponseInner> = serde_json::from_value(resp_json.clone()).expect("should parse into Vec<models::QueryManagedSubAccountAssetDetailsResponseInner>");
1266
1267            let dummy = DummyRestApiResponse {
1268                inner: Box::new(move || Box::pin(async move { Ok(dummy_response) })),
1269                status: 200,
1270                headers: HashMap::new(),
1271                rate_limits: None,
1272            };
1273
1274            Ok(dummy.into())
1275        }
1276
1277        async fn query_managed_sub_account_futures_asset_details(
1278            &self,
1279            _params: QueryManagedSubAccountFuturesAssetDetailsParams,
1280        ) -> anyhow::Result<
1281            RestApiResponse<models::QueryManagedSubAccountFuturesAssetDetailsResponse>,
1282        > {
1283            if self.force_error {
1284                return Err(ConnectorError::ConnectorClientError {
1285                    msg: "ResponseError".to_string(),
1286                    code: None,
1287                }
1288                .into());
1289            }
1290
1291            let resp_json: Value = serde_json::from_str(r#"{"code":"200","message":"OK","snapshotVos":[{"type":"FUTURES","updateTime":1672893855394,"data":{"assets":[{"asset":"USDT","marginBalance":100,"walletBalance":120}],"position":[{"symbol":"BTCUSDT","entryPrice":17000,"markPrice":17000,"positionAmt":1.0E-4}]}}]}"#).unwrap();
1292            let dummy_response: models::QueryManagedSubAccountFuturesAssetDetailsResponse =
1293                serde_json::from_value(resp_json.clone()).expect(
1294                    "should parse into models::QueryManagedSubAccountFuturesAssetDetailsResponse",
1295                );
1296
1297            let dummy = DummyRestApiResponse {
1298                inner: Box::new(move || Box::pin(async move { Ok(dummy_response) })),
1299                status: 200,
1300                headers: HashMap::new(),
1301                rate_limits: None,
1302            };
1303
1304            Ok(dummy.into())
1305        }
1306
1307        async fn query_managed_sub_account_list(
1308            &self,
1309            _params: QueryManagedSubAccountListParams,
1310        ) -> anyhow::Result<RestApiResponse<models::QueryManagedSubAccountListResponse>> {
1311            if self.force_error {
1312                return Err(ConnectorError::ConnectorClientError {
1313                    msg: "ResponseError".to_string(),
1314                    code: None,
1315                }
1316                .into());
1317            }
1318
1319            let resp_json: Value = serde_json::from_str(r#"{"total":3,"managerSubUserInfoVoList":[{"rootUserId":1000138475670,"managersubUserId":1000137842513,"bindParentUserId":1000138475669,"email":"test_0_virtual@kq3kno9imanagedsub.com","insertTimeStamp":1678435149000,"bindParentEmail":"wdyw8xsh8pey@test.com","isSubUserEnabled":true,"isUserActive":true,"isMarginEnabled":false,"isFutureEnabled":false,"isSignedLVTRiskAgreement":false},{"rootUserId":1000138475670,"managersubUserId":1000137842514,"bindParentUserId":1000138475669,"email":"test_1_virtual@4qd2u7zxmanagedsub.com","insertTimeStamp":1678435152000,"bindParentEmail":"wdyw8xsh8pey@test.com","isSubUserEnabled":true,"isUserActive":true,"isMarginEnabled":false,"isFutureEnabled":false,"isSignedLVTRiskAgreement":false},{"rootUserId":1000138475670,"managersubUserId":1000137842515,"bindParentUserId":1000138475669,"email":"test_2_virtual@akc05o8hmanagedsub.com","insertTimeStamp":1678435153000,"bindParentEmail":"wdyw8xsh8pey@test.com","isSubUserEnabled":true,"isUserActive":true,"isMarginEnabled":false,"isFutureEnabled":false,"isSignedLVTRiskAgreement":false}]}"#).unwrap();
1320            let dummy_response: models::QueryManagedSubAccountListResponse =
1321                serde_json::from_value(resp_json.clone())
1322                    .expect("should parse into models::QueryManagedSubAccountListResponse");
1323
1324            let dummy = DummyRestApiResponse {
1325                inner: Box::new(move || Box::pin(async move { Ok(dummy_response) })),
1326                status: 200,
1327                headers: HashMap::new(),
1328                rate_limits: None,
1329            };
1330
1331            Ok(dummy.into())
1332        }
1333
1334        async fn query_managed_sub_account_margin_asset_details(
1335            &self,
1336            _params: QueryManagedSubAccountMarginAssetDetailsParams,
1337        ) -> anyhow::Result<RestApiResponse<models::QueryManagedSubAccountMarginAssetDetailsResponse>>
1338        {
1339            if self.force_error {
1340                return Err(ConnectorError::ConnectorClientError {
1341                    msg: "ResponseError".to_string(),
1342                    code: None,
1343                }
1344                .into());
1345            }
1346
1347            let resp_json: Value = serde_json::from_str(r#"{"marginLevel":"999","totalAssetOfBtc":"0","totalLiabilityOfBtc":"0","totalNetAssetOfBtc":"0","userAssets":[{"asset":"MATIC","borrowed":"0","free":"0","interest":"0","locked":"0","netAsset":"0"},{"asset":"VET","borrowed":"0","free":"0","interest":"0","locked":"0","netAsset":"0"},{"asset":"BAKE","borrowed":"0","free":"0","interest":"0","locked":"0","netAsset":"0"}]}"#).unwrap();
1348            let dummy_response: models::QueryManagedSubAccountMarginAssetDetailsResponse =
1349                serde_json::from_value(resp_json.clone()).expect(
1350                    "should parse into models::QueryManagedSubAccountMarginAssetDetailsResponse",
1351                );
1352
1353            let dummy = DummyRestApiResponse {
1354                inner: Box::new(move || Box::pin(async move { Ok(dummy_response) })),
1355                status: 200,
1356                headers: HashMap::new(),
1357                rate_limits: None,
1358            };
1359
1360            Ok(dummy.into())
1361        }
1362
1363        async fn query_managed_sub_account_snapshot(
1364            &self,
1365            _params: QueryManagedSubAccountSnapshotParams,
1366        ) -> anyhow::Result<RestApiResponse<models::QueryManagedSubAccountSnapshotResponse>>
1367        {
1368            if self.force_error {
1369                return Err(ConnectorError::ConnectorClientError {
1370                    msg: "ResponseError".to_string(),
1371                    code: None,
1372                }
1373                .into());
1374            }
1375
1376            let resp_json: Value = serde_json::from_str(r#"{"code":200,"msg":"","snapshotVos":[{"data":{"balances":[{"asset":"BTC","free":"0.09905021","locked":"0.00000000"},{"asset":"USDT","free":"1.89109409","locked":"0.00000000"}],"totalAssetOfBtc":"0.09942700"},"type":"spot","updateTime":1576281599000},{"data":{"marginLevel":"2748.02909813","totalAssetOfBtc":"0.00274803","totalLiabilityOfBtc":"0.00000100","totalNetAssetOfBtc":"0.00274750","userAssets":[{"asset":"XRP","borrowed":"0.00000000","free":"1.00000000","interest":"0.00000000","locked":"0.00000000","netAsset":"1.00000000"}]},"type":"margin","updateTime":1576281599000},{"data":{"assets":[{"asset":"USDT","marginBalance":"118.99782335","walletBalance":"120.23811389"}],"position":[{"entryPrice":"7130.41000000","markPrice":"7257.66239673","positionAmt":"0.01000000","symbol":"BTCUSDT","unRealizedProfit":"1.24029054"}]},"type":"futures","updateTime":1576281599000}]}"#).unwrap();
1377            let dummy_response: models::QueryManagedSubAccountSnapshotResponse =
1378                serde_json::from_value(resp_json.clone())
1379                    .expect("should parse into models::QueryManagedSubAccountSnapshotResponse");
1380
1381            let dummy = DummyRestApiResponse {
1382                inner: Box::new(move || Box::pin(async move { Ok(dummy_response) })),
1383                status: 200,
1384                headers: HashMap::new(),
1385                rate_limits: None,
1386            };
1387
1388            Ok(dummy.into())
1389        }
1390
1391        async fn query_managed_sub_account_transfer_log_master_account_investor(
1392            &self,
1393            _params: QueryManagedSubAccountTransferLogMasterAccountInvestorParams,
1394        ) -> anyhow::Result<
1395            RestApiResponse<models::QueryManagedSubAccountTransferLogMasterAccountInvestorResponse>,
1396        > {
1397            if self.force_error {
1398                return Err(ConnectorError::ConnectorClientError {
1399                    msg: "ResponseError".to_string(),
1400                    code: None,
1401                }
1402                .into());
1403            }
1404
1405            let resp_json: Value = serde_json::from_str(r#"{"managerSubTransferHistoryVos":[{"fromEmail":"test_0_virtual@kq3kno9imanagedsub.com","fromAccountType":"SPOT","toEmail":"wdywl0lddakh@test.com","toAccountType":"SPOT","asset":"BNB","amount":"0.01","scheduledData":1679416673000,"createTime":1679416673000,"status":"SUCCESS","tranId":91077779},{"fromEmail":"wdywl0lddakh@test.com","fromAccountType":"SPOT","toEmail":"test_0_virtual@kq3kno9imanagedsub.com","toAccountType":"SPOT","asset":"BNB","amount":"1","scheduledData":1679416616000,"createTime":1679416616000,"status":"SUCCESS","tranId":91077676}],"count":2}"#).unwrap();
1406            let dummy_response : models::QueryManagedSubAccountTransferLogMasterAccountInvestorResponse = serde_json::from_value(resp_json.clone()).expect("should parse into models::QueryManagedSubAccountTransferLogMasterAccountInvestorResponse");
1407
1408            let dummy = DummyRestApiResponse {
1409                inner: Box::new(move || Box::pin(async move { Ok(dummy_response) })),
1410                status: 200,
1411                headers: HashMap::new(),
1412                rate_limits: None,
1413            };
1414
1415            Ok(dummy.into())
1416        }
1417
1418        async fn query_managed_sub_account_transfer_log_master_account_trading(
1419            &self,
1420            _params: QueryManagedSubAccountTransferLogMasterAccountTradingParams,
1421        ) -> anyhow::Result<
1422            RestApiResponse<models::QueryManagedSubAccountTransferLogMasterAccountTradingResponse>,
1423        > {
1424            if self.force_error {
1425                return Err(ConnectorError::ConnectorClientError {
1426                    msg: "ResponseError".to_string(),
1427                    code: None,
1428                }
1429                .into());
1430            }
1431
1432            let resp_json: Value = serde_json::from_str(r#"{"managerSubTransferHistoryVos":[{"fromEmail":"test_0_virtual@kq3kno9imanagedsub.com","fromAccountType":"SPOT","toEmail":"wdywl0lddakh@test.com","toAccountType":"SPOT","asset":"BNB","amount":"0.01","scheduledData":1679416673000,"createTime":1679416673000,"status":"SUCCESS","tranId":91077779},{"fromEmail":"wdywl0lddakh@test.com","fromAccountType":"SPOT","toEmail":"test_0_virtual@kq3kno9imanagedsub.com","toAccountType":"SPOT","asset":"BNB","amount":"1","scheduledData":1679416616000,"createTime":1679416616000,"status":"SUCCESS","tranId":91077676}],"count":2}"#).unwrap();
1433            let dummy_response : models::QueryManagedSubAccountTransferLogMasterAccountTradingResponse = serde_json::from_value(resp_json.clone()).expect("should parse into models::QueryManagedSubAccountTransferLogMasterAccountTradingResponse");
1434
1435            let dummy = DummyRestApiResponse {
1436                inner: Box::new(move || Box::pin(async move { Ok(dummy_response) })),
1437                status: 200,
1438                headers: HashMap::new(),
1439                rate_limits: None,
1440            };
1441
1442            Ok(dummy.into())
1443        }
1444
1445        async fn query_managed_sub_account_transfer_log_sub_account_trading(
1446            &self,
1447            _params: QueryManagedSubAccountTransferLogSubAccountTradingParams,
1448        ) -> anyhow::Result<
1449            RestApiResponse<models::QueryManagedSubAccountTransferLogSubAccountTradingResponse>,
1450        > {
1451            if self.force_error {
1452                return Err(ConnectorError::ConnectorClientError {
1453                    msg: "ResponseError".to_string(),
1454                    code: None,
1455                }
1456                .into());
1457            }
1458
1459            let resp_json: Value = serde_json::from_str(r#"{"managerSubTransferHistoryVos":[{"fromEmail":"test_0_virtual@kq3kno9imanagedsub.com","fromAccountType":"SPOT","toEmail":"wdywl0lddakh@test.com","toAccountType":"SPOT","asset":"BNB","amount":"0.01","scheduledData":1679416673000,"createTime":1679416673000,"status":"SUCCESS","tranId":91077779},{"fromEmail":"wdywl0lddakh@test.com","fromAccountType":"SPOT","toEmail":"test_0_virtual@kq3kno9imanagedsub.com","toAccountType":"SPOT","asset":"BNB","amount":"1","scheduledData":1679416616000,"createTime":1679416616000,"status":"SUCCESS","tranId":91077676}],"count":2}"#).unwrap();
1460            let dummy_response : models::QueryManagedSubAccountTransferLogSubAccountTradingResponse = serde_json::from_value(resp_json.clone()).expect("should parse into models::QueryManagedSubAccountTransferLogSubAccountTradingResponse");
1461
1462            let dummy = DummyRestApiResponse {
1463                inner: Box::new(move || Box::pin(async move { Ok(dummy_response) })),
1464                status: 200,
1465                headers: HashMap::new(),
1466                rate_limits: None,
1467            };
1468
1469            Ok(dummy.into())
1470        }
1471
1472        async fn withdrawl_assets_from_the_managed_sub_account(
1473            &self,
1474            _params: WithdrawlAssetsFromTheManagedSubAccountParams,
1475        ) -> anyhow::Result<RestApiResponse<models::WithdrawlAssetsFromTheManagedSubAccountResponse>>
1476        {
1477            if self.force_error {
1478                return Err(ConnectorError::ConnectorClientError {
1479                    msg: "ResponseError".to_string(),
1480                    code: None,
1481                }
1482                .into());
1483            }
1484
1485            let resp_json: Value = serde_json::from_str(r#"{"tranId":66157362489}"#).unwrap();
1486            let dummy_response: models::WithdrawlAssetsFromTheManagedSubAccountResponse =
1487                serde_json::from_value(resp_json.clone()).expect(
1488                    "should parse into models::WithdrawlAssetsFromTheManagedSubAccountResponse",
1489                );
1490
1491            let dummy = DummyRestApiResponse {
1492                inner: Box::new(move || Box::pin(async move { Ok(dummy_response) })),
1493                status: 200,
1494                headers: HashMap::new(),
1495                rate_limits: None,
1496            };
1497
1498            Ok(dummy.into())
1499        }
1500    }
1501
1502    #[test]
1503    fn deposit_assets_into_the_managed_sub_account_required_params_success() {
1504        TOKIO_SHARED_RT.block_on(async {
1505            let client = MockManagedSubAccountApiClient { force_error: false };
1506
1507            let params = DepositAssetsIntoTheManagedSubAccountParams::builder(
1508                "to_email_example".to_string(),
1509                "asset_example".to_string(),
1510                dec!(1.0),
1511            )
1512            .build()
1513            .unwrap();
1514
1515            let resp_json: Value = serde_json::from_str(r#"{"tranId":66157362489}"#).unwrap();
1516            let expected_response: models::DepositAssetsIntoTheManagedSubAccountResponse =
1517                serde_json::from_value(resp_json.clone()).expect(
1518                    "should parse into models::DepositAssetsIntoTheManagedSubAccountResponse",
1519                );
1520
1521            let resp = client
1522                .deposit_assets_into_the_managed_sub_account(params)
1523                .await
1524                .expect("Expected a response");
1525            let data_future = resp.data();
1526            let actual_response = data_future.await.unwrap();
1527            assert_eq!(actual_response, expected_response);
1528        });
1529    }
1530
1531    #[test]
1532    fn deposit_assets_into_the_managed_sub_account_optional_params_success() {
1533        TOKIO_SHARED_RT.block_on(async {
1534            let client = MockManagedSubAccountApiClient { force_error: false };
1535
1536            let params = DepositAssetsIntoTheManagedSubAccountParams::builder(
1537                "to_email_example".to_string(),
1538                "asset_example".to_string(),
1539                dec!(1.0),
1540            )
1541            .recv_window(5000)
1542            .build()
1543            .unwrap();
1544
1545            let resp_json: Value = serde_json::from_str(r#"{"tranId":66157362489}"#).unwrap();
1546            let expected_response: models::DepositAssetsIntoTheManagedSubAccountResponse =
1547                serde_json::from_value(resp_json.clone()).expect(
1548                    "should parse into models::DepositAssetsIntoTheManagedSubAccountResponse",
1549                );
1550
1551            let resp = client
1552                .deposit_assets_into_the_managed_sub_account(params)
1553                .await
1554                .expect("Expected a response");
1555            let data_future = resp.data();
1556            let actual_response = data_future.await.unwrap();
1557            assert_eq!(actual_response, expected_response);
1558        });
1559    }
1560
1561    #[test]
1562    fn deposit_assets_into_the_managed_sub_account_response_error() {
1563        TOKIO_SHARED_RT.block_on(async {
1564            let client = MockManagedSubAccountApiClient { force_error: true };
1565
1566            let params = DepositAssetsIntoTheManagedSubAccountParams::builder(
1567                "to_email_example".to_string(),
1568                "asset_example".to_string(),
1569                dec!(1.0),
1570            )
1571            .build()
1572            .unwrap();
1573
1574            match client
1575                .deposit_assets_into_the_managed_sub_account(params)
1576                .await
1577            {
1578                Ok(_) => panic!("Expected an error"),
1579                Err(err) => {
1580                    assert_eq!(err.to_string(), "Connector client error: ResponseError");
1581                }
1582            }
1583        });
1584    }
1585
1586    #[test]
1587    fn get_managed_sub_account_deposit_address_required_params_success() {
1588        TOKIO_SHARED_RT.block_on(async {
1589            let client = MockManagedSubAccountApiClient { force_error: false };
1590
1591            let params = GetManagedSubAccountDepositAddressParams::builder("sub-account-email@email.com".to_string(),"coin_example".to_string(),).build().unwrap();
1592
1593            let resp_json: Value = serde_json::from_str(r#"{"coin":"USDT","address":"0x206c22d833bb0bb2102da6b7c7d4c3eb14bcf73d","tag":"","url":"https://etherscan.io/address/0x206c22d833bb0bb2102da6b7c7d4c3eb14bcf73d"}"#).unwrap();
1594            let expected_response : models::GetManagedSubAccountDepositAddressResponse = serde_json::from_value(resp_json.clone()).expect("should parse into models::GetManagedSubAccountDepositAddressResponse");
1595
1596            let resp = client.get_managed_sub_account_deposit_address(params).await.expect("Expected a response");
1597            let data_future = resp.data();
1598            let actual_response = data_future.await.unwrap();
1599            assert_eq!(actual_response, expected_response);
1600        });
1601    }
1602
1603    #[test]
1604    fn get_managed_sub_account_deposit_address_optional_params_success() {
1605        TOKIO_SHARED_RT.block_on(async {
1606            let client = MockManagedSubAccountApiClient { force_error: false };
1607
1608            let params = GetManagedSubAccountDepositAddressParams::builder("sub-account-email@email.com".to_string(),"coin_example".to_string(),).network("network_example".to_string()).amount(dec!(1.0)).recv_window(5000).build().unwrap();
1609
1610            let resp_json: Value = serde_json::from_str(r#"{"coin":"USDT","address":"0x206c22d833bb0bb2102da6b7c7d4c3eb14bcf73d","tag":"","url":"https://etherscan.io/address/0x206c22d833bb0bb2102da6b7c7d4c3eb14bcf73d"}"#).unwrap();
1611            let expected_response : models::GetManagedSubAccountDepositAddressResponse = serde_json::from_value(resp_json.clone()).expect("should parse into models::GetManagedSubAccountDepositAddressResponse");
1612
1613            let resp = client.get_managed_sub_account_deposit_address(params).await.expect("Expected a response");
1614            let data_future = resp.data();
1615            let actual_response = data_future.await.unwrap();
1616            assert_eq!(actual_response, expected_response);
1617        });
1618    }
1619
1620    #[test]
1621    fn get_managed_sub_account_deposit_address_response_error() {
1622        TOKIO_SHARED_RT.block_on(async {
1623            let client = MockManagedSubAccountApiClient { force_error: true };
1624
1625            let params = GetManagedSubAccountDepositAddressParams::builder(
1626                "sub-account-email@email.com".to_string(),
1627                "coin_example".to_string(),
1628            )
1629            .build()
1630            .unwrap();
1631
1632            match client.get_managed_sub_account_deposit_address(params).await {
1633                Ok(_) => panic!("Expected an error"),
1634                Err(err) => {
1635                    assert_eq!(err.to_string(), "Connector client error: ResponseError");
1636                }
1637            }
1638        });
1639    }
1640
1641    #[test]
1642    fn query_managed_sub_account_asset_details_required_params_success() {
1643        TOKIO_SHARED_RT.block_on(async {
1644            let client = MockManagedSubAccountApiClient { force_error: false };
1645
1646            let params = QueryManagedSubAccountAssetDetailsParams::builder("sub-account-email@email.com".to_string(),).build().unwrap();
1647
1648            let resp_json: Value = serde_json::from_str(r#"[{"coin":"INJ","name":"Injective Protocol","totalBalance":"0","availableBalance":"0","inOrder":"0","btcValue":"0"},{"coin":"FILDOWN","name":"FILDOWN","totalBalance":"0","availableBalance":"0","inOrder":"0","btcValue":"0"}]"#).unwrap();
1649            let expected_response : Vec<models::QueryManagedSubAccountAssetDetailsResponseInner> = serde_json::from_value(resp_json.clone()).expect("should parse into Vec<models::QueryManagedSubAccountAssetDetailsResponseInner>");
1650
1651            let resp = client.query_managed_sub_account_asset_details(params).await.expect("Expected a response");
1652            let data_future = resp.data();
1653            let actual_response = data_future.await.unwrap();
1654            assert_eq!(actual_response, expected_response);
1655        });
1656    }
1657
1658    #[test]
1659    fn query_managed_sub_account_asset_details_optional_params_success() {
1660        TOKIO_SHARED_RT.block_on(async {
1661            let client = MockManagedSubAccountApiClient { force_error: false };
1662
1663            let params = QueryManagedSubAccountAssetDetailsParams::builder("sub-account-email@email.com".to_string(),).recv_window(5000).build().unwrap();
1664
1665            let resp_json: Value = serde_json::from_str(r#"[{"coin":"INJ","name":"Injective Protocol","totalBalance":"0","availableBalance":"0","inOrder":"0","btcValue":"0"},{"coin":"FILDOWN","name":"FILDOWN","totalBalance":"0","availableBalance":"0","inOrder":"0","btcValue":"0"}]"#).unwrap();
1666            let expected_response : Vec<models::QueryManagedSubAccountAssetDetailsResponseInner> = serde_json::from_value(resp_json.clone()).expect("should parse into Vec<models::QueryManagedSubAccountAssetDetailsResponseInner>");
1667
1668            let resp = client.query_managed_sub_account_asset_details(params).await.expect("Expected a response");
1669            let data_future = resp.data();
1670            let actual_response = data_future.await.unwrap();
1671            assert_eq!(actual_response, expected_response);
1672        });
1673    }
1674
1675    #[test]
1676    fn query_managed_sub_account_asset_details_response_error() {
1677        TOKIO_SHARED_RT.block_on(async {
1678            let client = MockManagedSubAccountApiClient { force_error: true };
1679
1680            let params = QueryManagedSubAccountAssetDetailsParams::builder(
1681                "sub-account-email@email.com".to_string(),
1682            )
1683            .build()
1684            .unwrap();
1685
1686            match client.query_managed_sub_account_asset_details(params).await {
1687                Ok(_) => panic!("Expected an error"),
1688                Err(err) => {
1689                    assert_eq!(err.to_string(), "Connector client error: ResponseError");
1690                }
1691            }
1692        });
1693    }
1694
1695    #[test]
1696    fn query_managed_sub_account_futures_asset_details_required_params_success() {
1697        TOKIO_SHARED_RT.block_on(async {
1698            let client = MockManagedSubAccountApiClient { force_error: false };
1699
1700            let params = QueryManagedSubAccountFuturesAssetDetailsParams::builder("sub-account-email@email.com".to_string(),).build().unwrap();
1701
1702            let resp_json: Value = serde_json::from_str(r#"{"code":"200","message":"OK","snapshotVos":[{"type":"FUTURES","updateTime":1672893855394,"data":{"assets":[{"asset":"USDT","marginBalance":100,"walletBalance":120}],"position":[{"symbol":"BTCUSDT","entryPrice":17000,"markPrice":17000,"positionAmt":1.0E-4}]}}]}"#).unwrap();
1703            let expected_response : models::QueryManagedSubAccountFuturesAssetDetailsResponse = serde_json::from_value(resp_json.clone()).expect("should parse into models::QueryManagedSubAccountFuturesAssetDetailsResponse");
1704
1705            let resp = client.query_managed_sub_account_futures_asset_details(params).await.expect("Expected a response");
1706            let data_future = resp.data();
1707            let actual_response = data_future.await.unwrap();
1708            assert_eq!(actual_response, expected_response);
1709        });
1710    }
1711
1712    #[test]
1713    fn query_managed_sub_account_futures_asset_details_optional_params_success() {
1714        TOKIO_SHARED_RT.block_on(async {
1715            let client = MockManagedSubAccountApiClient { force_error: false };
1716
1717            let params = QueryManagedSubAccountFuturesAssetDetailsParams::builder("sub-account-email@email.com".to_string(),).account_type("account_type_example".to_string()).build().unwrap();
1718
1719            let resp_json: Value = serde_json::from_str(r#"{"code":"200","message":"OK","snapshotVos":[{"type":"FUTURES","updateTime":1672893855394,"data":{"assets":[{"asset":"USDT","marginBalance":100,"walletBalance":120}],"position":[{"symbol":"BTCUSDT","entryPrice":17000,"markPrice":17000,"positionAmt":1.0E-4}]}}]}"#).unwrap();
1720            let expected_response : models::QueryManagedSubAccountFuturesAssetDetailsResponse = serde_json::from_value(resp_json.clone()).expect("should parse into models::QueryManagedSubAccountFuturesAssetDetailsResponse");
1721
1722            let resp = client.query_managed_sub_account_futures_asset_details(params).await.expect("Expected a response");
1723            let data_future = resp.data();
1724            let actual_response = data_future.await.unwrap();
1725            assert_eq!(actual_response, expected_response);
1726        });
1727    }
1728
1729    #[test]
1730    fn query_managed_sub_account_futures_asset_details_response_error() {
1731        TOKIO_SHARED_RT.block_on(async {
1732            let client = MockManagedSubAccountApiClient { force_error: true };
1733
1734            let params = QueryManagedSubAccountFuturesAssetDetailsParams::builder(
1735                "sub-account-email@email.com".to_string(),
1736            )
1737            .build()
1738            .unwrap();
1739
1740            match client
1741                .query_managed_sub_account_futures_asset_details(params)
1742                .await
1743            {
1744                Ok(_) => panic!("Expected an error"),
1745                Err(err) => {
1746                    assert_eq!(err.to_string(), "Connector client error: ResponseError");
1747                }
1748            }
1749        });
1750    }
1751
1752    #[test]
1753    fn query_managed_sub_account_list_required_params_success() {
1754        TOKIO_SHARED_RT.block_on(async {
1755            let client = MockManagedSubAccountApiClient { force_error: false };
1756
1757            let params = QueryManagedSubAccountListParams::builder().build().unwrap();
1758
1759            let resp_json: Value = serde_json::from_str(r#"{"total":3,"managerSubUserInfoVoList":[{"rootUserId":1000138475670,"managersubUserId":1000137842513,"bindParentUserId":1000138475669,"email":"test_0_virtual@kq3kno9imanagedsub.com","insertTimeStamp":1678435149000,"bindParentEmail":"wdyw8xsh8pey@test.com","isSubUserEnabled":true,"isUserActive":true,"isMarginEnabled":false,"isFutureEnabled":false,"isSignedLVTRiskAgreement":false},{"rootUserId":1000138475670,"managersubUserId":1000137842514,"bindParentUserId":1000138475669,"email":"test_1_virtual@4qd2u7zxmanagedsub.com","insertTimeStamp":1678435152000,"bindParentEmail":"wdyw8xsh8pey@test.com","isSubUserEnabled":true,"isUserActive":true,"isMarginEnabled":false,"isFutureEnabled":false,"isSignedLVTRiskAgreement":false},{"rootUserId":1000138475670,"managersubUserId":1000137842515,"bindParentUserId":1000138475669,"email":"test_2_virtual@akc05o8hmanagedsub.com","insertTimeStamp":1678435153000,"bindParentEmail":"wdyw8xsh8pey@test.com","isSubUserEnabled":true,"isUserActive":true,"isMarginEnabled":false,"isFutureEnabled":false,"isSignedLVTRiskAgreement":false}]}"#).unwrap();
1760            let expected_response : models::QueryManagedSubAccountListResponse = serde_json::from_value(resp_json.clone()).expect("should parse into models::QueryManagedSubAccountListResponse");
1761
1762            let resp = client.query_managed_sub_account_list(params).await.expect("Expected a response");
1763            let data_future = resp.data();
1764            let actual_response = data_future.await.unwrap();
1765            assert_eq!(actual_response, expected_response);
1766        });
1767    }
1768
1769    #[test]
1770    fn query_managed_sub_account_list_optional_params_success() {
1771        TOKIO_SHARED_RT.block_on(async {
1772            let client = MockManagedSubAccountApiClient { force_error: false };
1773
1774            let params = QueryManagedSubAccountListParams::builder().email("email_example".to_string()).page(1).limit(1).recv_window(5000).build().unwrap();
1775
1776            let resp_json: Value = serde_json::from_str(r#"{"total":3,"managerSubUserInfoVoList":[{"rootUserId":1000138475670,"managersubUserId":1000137842513,"bindParentUserId":1000138475669,"email":"test_0_virtual@kq3kno9imanagedsub.com","insertTimeStamp":1678435149000,"bindParentEmail":"wdyw8xsh8pey@test.com","isSubUserEnabled":true,"isUserActive":true,"isMarginEnabled":false,"isFutureEnabled":false,"isSignedLVTRiskAgreement":false},{"rootUserId":1000138475670,"managersubUserId":1000137842514,"bindParentUserId":1000138475669,"email":"test_1_virtual@4qd2u7zxmanagedsub.com","insertTimeStamp":1678435152000,"bindParentEmail":"wdyw8xsh8pey@test.com","isSubUserEnabled":true,"isUserActive":true,"isMarginEnabled":false,"isFutureEnabled":false,"isSignedLVTRiskAgreement":false},{"rootUserId":1000138475670,"managersubUserId":1000137842515,"bindParentUserId":1000138475669,"email":"test_2_virtual@akc05o8hmanagedsub.com","insertTimeStamp":1678435153000,"bindParentEmail":"wdyw8xsh8pey@test.com","isSubUserEnabled":true,"isUserActive":true,"isMarginEnabled":false,"isFutureEnabled":false,"isSignedLVTRiskAgreement":false}]}"#).unwrap();
1777            let expected_response : models::QueryManagedSubAccountListResponse = serde_json::from_value(resp_json.clone()).expect("should parse into models::QueryManagedSubAccountListResponse");
1778
1779            let resp = client.query_managed_sub_account_list(params).await.expect("Expected a response");
1780            let data_future = resp.data();
1781            let actual_response = data_future.await.unwrap();
1782            assert_eq!(actual_response, expected_response);
1783        });
1784    }
1785
1786    #[test]
1787    fn query_managed_sub_account_list_response_error() {
1788        TOKIO_SHARED_RT.block_on(async {
1789            let client = MockManagedSubAccountApiClient { force_error: true };
1790
1791            let params = QueryManagedSubAccountListParams::builder().build().unwrap();
1792
1793            match client.query_managed_sub_account_list(params).await {
1794                Ok(_) => panic!("Expected an error"),
1795                Err(err) => {
1796                    assert_eq!(err.to_string(), "Connector client error: ResponseError");
1797                }
1798            }
1799        });
1800    }
1801
1802    #[test]
1803    fn query_managed_sub_account_margin_asset_details_required_params_success() {
1804        TOKIO_SHARED_RT.block_on(async {
1805            let client = MockManagedSubAccountApiClient { force_error: false };
1806
1807            let params = QueryManagedSubAccountMarginAssetDetailsParams::builder("sub-account-email@email.com".to_string(),).build().unwrap();
1808
1809            let resp_json: Value = serde_json::from_str(r#"{"marginLevel":"999","totalAssetOfBtc":"0","totalLiabilityOfBtc":"0","totalNetAssetOfBtc":"0","userAssets":[{"asset":"MATIC","borrowed":"0","free":"0","interest":"0","locked":"0","netAsset":"0"},{"asset":"VET","borrowed":"0","free":"0","interest":"0","locked":"0","netAsset":"0"},{"asset":"BAKE","borrowed":"0","free":"0","interest":"0","locked":"0","netAsset":"0"}]}"#).unwrap();
1810            let expected_response : models::QueryManagedSubAccountMarginAssetDetailsResponse = serde_json::from_value(resp_json.clone()).expect("should parse into models::QueryManagedSubAccountMarginAssetDetailsResponse");
1811
1812            let resp = client.query_managed_sub_account_margin_asset_details(params).await.expect("Expected a response");
1813            let data_future = resp.data();
1814            let actual_response = data_future.await.unwrap();
1815            assert_eq!(actual_response, expected_response);
1816        });
1817    }
1818
1819    #[test]
1820    fn query_managed_sub_account_margin_asset_details_optional_params_success() {
1821        TOKIO_SHARED_RT.block_on(async {
1822            let client = MockManagedSubAccountApiClient { force_error: false };
1823
1824            let params = QueryManagedSubAccountMarginAssetDetailsParams::builder("sub-account-email@email.com".to_string(),).account_type("account_type_example".to_string()).build().unwrap();
1825
1826            let resp_json: Value = serde_json::from_str(r#"{"marginLevel":"999","totalAssetOfBtc":"0","totalLiabilityOfBtc":"0","totalNetAssetOfBtc":"0","userAssets":[{"asset":"MATIC","borrowed":"0","free":"0","interest":"0","locked":"0","netAsset":"0"},{"asset":"VET","borrowed":"0","free":"0","interest":"0","locked":"0","netAsset":"0"},{"asset":"BAKE","borrowed":"0","free":"0","interest":"0","locked":"0","netAsset":"0"}]}"#).unwrap();
1827            let expected_response : models::QueryManagedSubAccountMarginAssetDetailsResponse = serde_json::from_value(resp_json.clone()).expect("should parse into models::QueryManagedSubAccountMarginAssetDetailsResponse");
1828
1829            let resp = client.query_managed_sub_account_margin_asset_details(params).await.expect("Expected a response");
1830            let data_future = resp.data();
1831            let actual_response = data_future.await.unwrap();
1832            assert_eq!(actual_response, expected_response);
1833        });
1834    }
1835
1836    #[test]
1837    fn query_managed_sub_account_margin_asset_details_response_error() {
1838        TOKIO_SHARED_RT.block_on(async {
1839            let client = MockManagedSubAccountApiClient { force_error: true };
1840
1841            let params = QueryManagedSubAccountMarginAssetDetailsParams::builder(
1842                "sub-account-email@email.com".to_string(),
1843            )
1844            .build()
1845            .unwrap();
1846
1847            match client
1848                .query_managed_sub_account_margin_asset_details(params)
1849                .await
1850            {
1851                Ok(_) => panic!("Expected an error"),
1852                Err(err) => {
1853                    assert_eq!(err.to_string(), "Connector client error: ResponseError");
1854                }
1855            }
1856        });
1857    }
1858
1859    #[test]
1860    fn query_managed_sub_account_snapshot_required_params_success() {
1861        TOKIO_SHARED_RT.block_on(async {
1862            let client = MockManagedSubAccountApiClient { force_error: false };
1863
1864            let params = QueryManagedSubAccountSnapshotParams::builder("sub-account-email@email.com".to_string(),"r#type_example".to_string(),).build().unwrap();
1865
1866            let resp_json: Value = serde_json::from_str(r#"{"code":200,"msg":"","snapshotVos":[{"data":{"balances":[{"asset":"BTC","free":"0.09905021","locked":"0.00000000"},{"asset":"USDT","free":"1.89109409","locked":"0.00000000"}],"totalAssetOfBtc":"0.09942700"},"type":"spot","updateTime":1576281599000},{"data":{"marginLevel":"2748.02909813","totalAssetOfBtc":"0.00274803","totalLiabilityOfBtc":"0.00000100","totalNetAssetOfBtc":"0.00274750","userAssets":[{"asset":"XRP","borrowed":"0.00000000","free":"1.00000000","interest":"0.00000000","locked":"0.00000000","netAsset":"1.00000000"}]},"type":"margin","updateTime":1576281599000},{"data":{"assets":[{"asset":"USDT","marginBalance":"118.99782335","walletBalance":"120.23811389"}],"position":[{"entryPrice":"7130.41000000","markPrice":"7257.66239673","positionAmt":"0.01000000","symbol":"BTCUSDT","unRealizedProfit":"1.24029054"}]},"type":"futures","updateTime":1576281599000}]}"#).unwrap();
1867            let expected_response : models::QueryManagedSubAccountSnapshotResponse = serde_json::from_value(resp_json.clone()).expect("should parse into models::QueryManagedSubAccountSnapshotResponse");
1868
1869            let resp = client.query_managed_sub_account_snapshot(params).await.expect("Expected a response");
1870            let data_future = resp.data();
1871            let actual_response = data_future.await.unwrap();
1872            assert_eq!(actual_response, expected_response);
1873        });
1874    }
1875
1876    #[test]
1877    fn query_managed_sub_account_snapshot_optional_params_success() {
1878        TOKIO_SHARED_RT.block_on(async {
1879            let client = MockManagedSubAccountApiClient { force_error: false };
1880
1881            let params = QueryManagedSubAccountSnapshotParams::builder("sub-account-email@email.com".to_string(),"r#type_example".to_string(),).start_time(1623319461670).end_time(1641782889000).limit(1).recv_window(5000).build().unwrap();
1882
1883            let resp_json: Value = serde_json::from_str(r#"{"code":200,"msg":"","snapshotVos":[{"data":{"balances":[{"asset":"BTC","free":"0.09905021","locked":"0.00000000"},{"asset":"USDT","free":"1.89109409","locked":"0.00000000"}],"totalAssetOfBtc":"0.09942700"},"type":"spot","updateTime":1576281599000},{"data":{"marginLevel":"2748.02909813","totalAssetOfBtc":"0.00274803","totalLiabilityOfBtc":"0.00000100","totalNetAssetOfBtc":"0.00274750","userAssets":[{"asset":"XRP","borrowed":"0.00000000","free":"1.00000000","interest":"0.00000000","locked":"0.00000000","netAsset":"1.00000000"}]},"type":"margin","updateTime":1576281599000},{"data":{"assets":[{"asset":"USDT","marginBalance":"118.99782335","walletBalance":"120.23811389"}],"position":[{"entryPrice":"7130.41000000","markPrice":"7257.66239673","positionAmt":"0.01000000","symbol":"BTCUSDT","unRealizedProfit":"1.24029054"}]},"type":"futures","updateTime":1576281599000}]}"#).unwrap();
1884            let expected_response : models::QueryManagedSubAccountSnapshotResponse = serde_json::from_value(resp_json.clone()).expect("should parse into models::QueryManagedSubAccountSnapshotResponse");
1885
1886            let resp = client.query_managed_sub_account_snapshot(params).await.expect("Expected a response");
1887            let data_future = resp.data();
1888            let actual_response = data_future.await.unwrap();
1889            assert_eq!(actual_response, expected_response);
1890        });
1891    }
1892
1893    #[test]
1894    fn query_managed_sub_account_snapshot_response_error() {
1895        TOKIO_SHARED_RT.block_on(async {
1896            let client = MockManagedSubAccountApiClient { force_error: true };
1897
1898            let params = QueryManagedSubAccountSnapshotParams::builder(
1899                "sub-account-email@email.com".to_string(),
1900                "r#type_example".to_string(),
1901            )
1902            .build()
1903            .unwrap();
1904
1905            match client.query_managed_sub_account_snapshot(params).await {
1906                Ok(_) => panic!("Expected an error"),
1907                Err(err) => {
1908                    assert_eq!(err.to_string(), "Connector client error: ResponseError");
1909                }
1910            }
1911        });
1912    }
1913
1914    #[test]
1915    fn query_managed_sub_account_transfer_log_master_account_investor_required_params_success() {
1916        TOKIO_SHARED_RT.block_on(async {
1917            let client = MockManagedSubAccountApiClient { force_error: false };
1918
1919            let params = QueryManagedSubAccountTransferLogMasterAccountInvestorParams::builder("sub-account-email@email.com".to_string(),1623319461670,1641782889000,789,789,).build().unwrap();
1920
1921            let resp_json: Value = serde_json::from_str(r#"{"managerSubTransferHistoryVos":[{"fromEmail":"test_0_virtual@kq3kno9imanagedsub.com","fromAccountType":"SPOT","toEmail":"wdywl0lddakh@test.com","toAccountType":"SPOT","asset":"BNB","amount":"0.01","scheduledData":1679416673000,"createTime":1679416673000,"status":"SUCCESS","tranId":91077779},{"fromEmail":"wdywl0lddakh@test.com","fromAccountType":"SPOT","toEmail":"test_0_virtual@kq3kno9imanagedsub.com","toAccountType":"SPOT","asset":"BNB","amount":"1","scheduledData":1679416616000,"createTime":1679416616000,"status":"SUCCESS","tranId":91077676}],"count":2}"#).unwrap();
1922            let expected_response : models::QueryManagedSubAccountTransferLogMasterAccountInvestorResponse = serde_json::from_value(resp_json.clone()).expect("should parse into models::QueryManagedSubAccountTransferLogMasterAccountInvestorResponse");
1923
1924            let resp = client.query_managed_sub_account_transfer_log_master_account_investor(params).await.expect("Expected a response");
1925            let data_future = resp.data();
1926            let actual_response = data_future.await.unwrap();
1927            assert_eq!(actual_response, expected_response);
1928        });
1929    }
1930
1931    #[test]
1932    fn query_managed_sub_account_transfer_log_master_account_investor_optional_params_success() {
1933        TOKIO_SHARED_RT.block_on(async {
1934            let client = MockManagedSubAccountApiClient { force_error: false };
1935
1936            let params = QueryManagedSubAccountTransferLogMasterAccountInvestorParams::builder("sub-account-email@email.com".to_string(),1623319461670,1641782889000,789,789,).transfers("transfers_example".to_string()).transfer_function_account_type("transfer_function_account_type_example".to_string()).build().unwrap();
1937
1938            let resp_json: Value = serde_json::from_str(r#"{"managerSubTransferHistoryVos":[{"fromEmail":"test_0_virtual@kq3kno9imanagedsub.com","fromAccountType":"SPOT","toEmail":"wdywl0lddakh@test.com","toAccountType":"SPOT","asset":"BNB","amount":"0.01","scheduledData":1679416673000,"createTime":1679416673000,"status":"SUCCESS","tranId":91077779},{"fromEmail":"wdywl0lddakh@test.com","fromAccountType":"SPOT","toEmail":"test_0_virtual@kq3kno9imanagedsub.com","toAccountType":"SPOT","asset":"BNB","amount":"1","scheduledData":1679416616000,"createTime":1679416616000,"status":"SUCCESS","tranId":91077676}],"count":2}"#).unwrap();
1939            let expected_response : models::QueryManagedSubAccountTransferLogMasterAccountInvestorResponse = serde_json::from_value(resp_json.clone()).expect("should parse into models::QueryManagedSubAccountTransferLogMasterAccountInvestorResponse");
1940
1941            let resp = client.query_managed_sub_account_transfer_log_master_account_investor(params).await.expect("Expected a response");
1942            let data_future = resp.data();
1943            let actual_response = data_future.await.unwrap();
1944            assert_eq!(actual_response, expected_response);
1945        });
1946    }
1947
1948    #[test]
1949    fn query_managed_sub_account_transfer_log_master_account_investor_response_error() {
1950        TOKIO_SHARED_RT.block_on(async {
1951            let client = MockManagedSubAccountApiClient { force_error: true };
1952
1953            let params = QueryManagedSubAccountTransferLogMasterAccountInvestorParams::builder(
1954                "sub-account-email@email.com".to_string(),
1955                1623319461670,
1956                1641782889000,
1957                789,
1958                789,
1959            )
1960            .build()
1961            .unwrap();
1962
1963            match client
1964                .query_managed_sub_account_transfer_log_master_account_investor(params)
1965                .await
1966            {
1967                Ok(_) => panic!("Expected an error"),
1968                Err(err) => {
1969                    assert_eq!(err.to_string(), "Connector client error: ResponseError");
1970                }
1971            }
1972        });
1973    }
1974
1975    #[test]
1976    fn query_managed_sub_account_transfer_log_master_account_trading_required_params_success() {
1977        TOKIO_SHARED_RT.block_on(async {
1978            let client = MockManagedSubAccountApiClient { force_error: false };
1979
1980            let params = QueryManagedSubAccountTransferLogMasterAccountTradingParams::builder("sub-account-email@email.com".to_string(),1623319461670,1641782889000,789,789,).build().unwrap();
1981
1982            let resp_json: Value = serde_json::from_str(r#"{"managerSubTransferHistoryVos":[{"fromEmail":"test_0_virtual@kq3kno9imanagedsub.com","fromAccountType":"SPOT","toEmail":"wdywl0lddakh@test.com","toAccountType":"SPOT","asset":"BNB","amount":"0.01","scheduledData":1679416673000,"createTime":1679416673000,"status":"SUCCESS","tranId":91077779},{"fromEmail":"wdywl0lddakh@test.com","fromAccountType":"SPOT","toEmail":"test_0_virtual@kq3kno9imanagedsub.com","toAccountType":"SPOT","asset":"BNB","amount":"1","scheduledData":1679416616000,"createTime":1679416616000,"status":"SUCCESS","tranId":91077676}],"count":2}"#).unwrap();
1983            let expected_response : models::QueryManagedSubAccountTransferLogMasterAccountTradingResponse = serde_json::from_value(resp_json.clone()).expect("should parse into models::QueryManagedSubAccountTransferLogMasterAccountTradingResponse");
1984
1985            let resp = client.query_managed_sub_account_transfer_log_master_account_trading(params).await.expect("Expected a response");
1986            let data_future = resp.data();
1987            let actual_response = data_future.await.unwrap();
1988            assert_eq!(actual_response, expected_response);
1989        });
1990    }
1991
1992    #[test]
1993    fn query_managed_sub_account_transfer_log_master_account_trading_optional_params_success() {
1994        TOKIO_SHARED_RT.block_on(async {
1995            let client = MockManagedSubAccountApiClient { force_error: false };
1996
1997            let params = QueryManagedSubAccountTransferLogMasterAccountTradingParams::builder("sub-account-email@email.com".to_string(),1623319461670,1641782889000,789,789,).transfers("transfers_example".to_string()).transfer_function_account_type("transfer_function_account_type_example".to_string()).build().unwrap();
1998
1999            let resp_json: Value = serde_json::from_str(r#"{"managerSubTransferHistoryVos":[{"fromEmail":"test_0_virtual@kq3kno9imanagedsub.com","fromAccountType":"SPOT","toEmail":"wdywl0lddakh@test.com","toAccountType":"SPOT","asset":"BNB","amount":"0.01","scheduledData":1679416673000,"createTime":1679416673000,"status":"SUCCESS","tranId":91077779},{"fromEmail":"wdywl0lddakh@test.com","fromAccountType":"SPOT","toEmail":"test_0_virtual@kq3kno9imanagedsub.com","toAccountType":"SPOT","asset":"BNB","amount":"1","scheduledData":1679416616000,"createTime":1679416616000,"status":"SUCCESS","tranId":91077676}],"count":2}"#).unwrap();
2000            let expected_response : models::QueryManagedSubAccountTransferLogMasterAccountTradingResponse = serde_json::from_value(resp_json.clone()).expect("should parse into models::QueryManagedSubAccountTransferLogMasterAccountTradingResponse");
2001
2002            let resp = client.query_managed_sub_account_transfer_log_master_account_trading(params).await.expect("Expected a response");
2003            let data_future = resp.data();
2004            let actual_response = data_future.await.unwrap();
2005            assert_eq!(actual_response, expected_response);
2006        });
2007    }
2008
2009    #[test]
2010    fn query_managed_sub_account_transfer_log_master_account_trading_response_error() {
2011        TOKIO_SHARED_RT.block_on(async {
2012            let client = MockManagedSubAccountApiClient { force_error: true };
2013
2014            let params = QueryManagedSubAccountTransferLogMasterAccountTradingParams::builder(
2015                "sub-account-email@email.com".to_string(),
2016                1623319461670,
2017                1641782889000,
2018                789,
2019                789,
2020            )
2021            .build()
2022            .unwrap();
2023
2024            match client
2025                .query_managed_sub_account_transfer_log_master_account_trading(params)
2026                .await
2027            {
2028                Ok(_) => panic!("Expected an error"),
2029                Err(err) => {
2030                    assert_eq!(err.to_string(), "Connector client error: ResponseError");
2031                }
2032            }
2033        });
2034    }
2035
2036    #[test]
2037    fn query_managed_sub_account_transfer_log_sub_account_trading_required_params_success() {
2038        TOKIO_SHARED_RT.block_on(async {
2039            let client = MockManagedSubAccountApiClient { force_error: false };
2040
2041            let params = QueryManagedSubAccountTransferLogSubAccountTradingParams::builder(1623319461670,1641782889000,789,789,).build().unwrap();
2042
2043            let resp_json: Value = serde_json::from_str(r#"{"managerSubTransferHistoryVos":[{"fromEmail":"test_0_virtual@kq3kno9imanagedsub.com","fromAccountType":"SPOT","toEmail":"wdywl0lddakh@test.com","toAccountType":"SPOT","asset":"BNB","amount":"0.01","scheduledData":1679416673000,"createTime":1679416673000,"status":"SUCCESS","tranId":91077779},{"fromEmail":"wdywl0lddakh@test.com","fromAccountType":"SPOT","toEmail":"test_0_virtual@kq3kno9imanagedsub.com","toAccountType":"SPOT","asset":"BNB","amount":"1","scheduledData":1679416616000,"createTime":1679416616000,"status":"SUCCESS","tranId":91077676}],"count":2}"#).unwrap();
2044            let expected_response : models::QueryManagedSubAccountTransferLogSubAccountTradingResponse = serde_json::from_value(resp_json.clone()).expect("should parse into models::QueryManagedSubAccountTransferLogSubAccountTradingResponse");
2045
2046            let resp = client.query_managed_sub_account_transfer_log_sub_account_trading(params).await.expect("Expected a response");
2047            let data_future = resp.data();
2048            let actual_response = data_future.await.unwrap();
2049            assert_eq!(actual_response, expected_response);
2050        });
2051    }
2052
2053    #[test]
2054    fn query_managed_sub_account_transfer_log_sub_account_trading_optional_params_success() {
2055        TOKIO_SHARED_RT.block_on(async {
2056            let client = MockManagedSubAccountApiClient { force_error: false };
2057
2058            let params = QueryManagedSubAccountTransferLogSubAccountTradingParams::builder(1623319461670,1641782889000,789,789,).transfers("transfers_example".to_string()).transfer_function_account_type("transfer_function_account_type_example".to_string()).recv_window(5000).build().unwrap();
2059
2060            let resp_json: Value = serde_json::from_str(r#"{"managerSubTransferHistoryVos":[{"fromEmail":"test_0_virtual@kq3kno9imanagedsub.com","fromAccountType":"SPOT","toEmail":"wdywl0lddakh@test.com","toAccountType":"SPOT","asset":"BNB","amount":"0.01","scheduledData":1679416673000,"createTime":1679416673000,"status":"SUCCESS","tranId":91077779},{"fromEmail":"wdywl0lddakh@test.com","fromAccountType":"SPOT","toEmail":"test_0_virtual@kq3kno9imanagedsub.com","toAccountType":"SPOT","asset":"BNB","amount":"1","scheduledData":1679416616000,"createTime":1679416616000,"status":"SUCCESS","tranId":91077676}],"count":2}"#).unwrap();
2061            let expected_response : models::QueryManagedSubAccountTransferLogSubAccountTradingResponse = serde_json::from_value(resp_json.clone()).expect("should parse into models::QueryManagedSubAccountTransferLogSubAccountTradingResponse");
2062
2063            let resp = client.query_managed_sub_account_transfer_log_sub_account_trading(params).await.expect("Expected a response");
2064            let data_future = resp.data();
2065            let actual_response = data_future.await.unwrap();
2066            assert_eq!(actual_response, expected_response);
2067        });
2068    }
2069
2070    #[test]
2071    fn query_managed_sub_account_transfer_log_sub_account_trading_response_error() {
2072        TOKIO_SHARED_RT.block_on(async {
2073            let client = MockManagedSubAccountApiClient { force_error: true };
2074
2075            let params = QueryManagedSubAccountTransferLogSubAccountTradingParams::builder(
2076                1623319461670,
2077                1641782889000,
2078                789,
2079                789,
2080            )
2081            .build()
2082            .unwrap();
2083
2084            match client
2085                .query_managed_sub_account_transfer_log_sub_account_trading(params)
2086                .await
2087            {
2088                Ok(_) => panic!("Expected an error"),
2089                Err(err) => {
2090                    assert_eq!(err.to_string(), "Connector client error: ResponseError");
2091                }
2092            }
2093        });
2094    }
2095
2096    #[test]
2097    fn withdrawl_assets_from_the_managed_sub_account_required_params_success() {
2098        TOKIO_SHARED_RT.block_on(async {
2099            let client = MockManagedSubAccountApiClient { force_error: false };
2100
2101            let params = WithdrawlAssetsFromTheManagedSubAccountParams::builder(
2102                "from_email_example".to_string(),
2103                "asset_example".to_string(),
2104                dec!(1.0),
2105            )
2106            .build()
2107            .unwrap();
2108
2109            let resp_json: Value = serde_json::from_str(r#"{"tranId":66157362489}"#).unwrap();
2110            let expected_response: models::WithdrawlAssetsFromTheManagedSubAccountResponse =
2111                serde_json::from_value(resp_json.clone()).expect(
2112                    "should parse into models::WithdrawlAssetsFromTheManagedSubAccountResponse",
2113                );
2114
2115            let resp = client
2116                .withdrawl_assets_from_the_managed_sub_account(params)
2117                .await
2118                .expect("Expected a response");
2119            let data_future = resp.data();
2120            let actual_response = data_future.await.unwrap();
2121            assert_eq!(actual_response, expected_response);
2122        });
2123    }
2124
2125    #[test]
2126    fn withdrawl_assets_from_the_managed_sub_account_optional_params_success() {
2127        TOKIO_SHARED_RT.block_on(async {
2128            let client = MockManagedSubAccountApiClient { force_error: false };
2129
2130            let params = WithdrawlAssetsFromTheManagedSubAccountParams::builder(
2131                "from_email_example".to_string(),
2132                "asset_example".to_string(),
2133                dec!(1.0),
2134            )
2135            .transfer_date(789)
2136            .recv_window(5000)
2137            .build()
2138            .unwrap();
2139
2140            let resp_json: Value = serde_json::from_str(r#"{"tranId":66157362489}"#).unwrap();
2141            let expected_response: models::WithdrawlAssetsFromTheManagedSubAccountResponse =
2142                serde_json::from_value(resp_json.clone()).expect(
2143                    "should parse into models::WithdrawlAssetsFromTheManagedSubAccountResponse",
2144                );
2145
2146            let resp = client
2147                .withdrawl_assets_from_the_managed_sub_account(params)
2148                .await
2149                .expect("Expected a response");
2150            let data_future = resp.data();
2151            let actual_response = data_future.await.unwrap();
2152            assert_eq!(actual_response, expected_response);
2153        });
2154    }
2155
2156    #[test]
2157    fn withdrawl_assets_from_the_managed_sub_account_response_error() {
2158        TOKIO_SHARED_RT.block_on(async {
2159            let client = MockManagedSubAccountApiClient { force_error: true };
2160
2161            let params = WithdrawlAssetsFromTheManagedSubAccountParams::builder(
2162                "from_email_example".to_string(),
2163                "asset_example".to_string(),
2164                dec!(1.0),
2165            )
2166            .build()
2167            .unwrap();
2168
2169            match client
2170                .withdrawl_assets_from_the_managed_sub_account(params)
2171                .await
2172            {
2173                Ok(_) => panic!("Expected an error"),
2174                Err(err) => {
2175                    assert_eq!(err.to_string(), "Connector client error: ResponseError");
2176                }
2177            }
2178        });
2179    }
2180}