stripe_shared/
funding_instructions_bank_transfer_zengin_record.rs

1/// Zengin Records contain Japan bank account details per the Zengin format.
2#[derive(Clone, Debug)]
3#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
4#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
5pub struct FundingInstructionsBankTransferZenginRecord {
6    pub account_holder_address: stripe_shared::Address,
7    /// The account holder name
8    pub account_holder_name: Option<String>,
9    /// The account number
10    pub account_number: Option<String>,
11    /// The bank account type. In Japan, this can only be `futsu` or `toza`.
12    pub account_type: Option<String>,
13    pub bank_address: stripe_shared::Address,
14    /// The bank code of the account
15    pub bank_code: Option<String>,
16    /// The bank name of the account
17    pub bank_name: Option<String>,
18    /// The branch code of the account
19    pub branch_code: Option<String>,
20    /// The branch name of the account
21    pub branch_name: Option<String>,
22}
23#[doc(hidden)]
24pub struct FundingInstructionsBankTransferZenginRecordBuilder {
25    account_holder_address: Option<stripe_shared::Address>,
26    account_holder_name: Option<Option<String>>,
27    account_number: Option<Option<String>>,
28    account_type: Option<Option<String>>,
29    bank_address: Option<stripe_shared::Address>,
30    bank_code: Option<Option<String>>,
31    bank_name: Option<Option<String>>,
32    branch_code: Option<Option<String>>,
33    branch_name: Option<Option<String>>,
34}
35
36#[allow(
37    unused_variables,
38    irrefutable_let_patterns,
39    clippy::let_unit_value,
40    clippy::match_single_binding,
41    clippy::single_match
42)]
43const _: () = {
44    use miniserde::de::{Map, Visitor};
45    use miniserde::json::Value;
46    use miniserde::{Deserialize, Result, make_place};
47    use stripe_types::miniserde_helpers::FromValueOpt;
48    use stripe_types::{MapBuilder, ObjectDeser};
49
50    make_place!(Place);
51
52    impl Deserialize for FundingInstructionsBankTransferZenginRecord {
53        fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
54            Place::new(out)
55        }
56    }
57
58    struct Builder<'a> {
59        out: &'a mut Option<FundingInstructionsBankTransferZenginRecord>,
60        builder: FundingInstructionsBankTransferZenginRecordBuilder,
61    }
62
63    impl Visitor for Place<FundingInstructionsBankTransferZenginRecord> {
64        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
65            Ok(Box::new(Builder {
66                out: &mut self.out,
67                builder: FundingInstructionsBankTransferZenginRecordBuilder::deser_default(),
68            }))
69        }
70    }
71
72    impl MapBuilder for FundingInstructionsBankTransferZenginRecordBuilder {
73        type Out = FundingInstructionsBankTransferZenginRecord;
74        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
75            Ok(match k {
76                "account_holder_address" => Deserialize::begin(&mut self.account_holder_address),
77                "account_holder_name" => Deserialize::begin(&mut self.account_holder_name),
78                "account_number" => Deserialize::begin(&mut self.account_number),
79                "account_type" => Deserialize::begin(&mut self.account_type),
80                "bank_address" => Deserialize::begin(&mut self.bank_address),
81                "bank_code" => Deserialize::begin(&mut self.bank_code),
82                "bank_name" => Deserialize::begin(&mut self.bank_name),
83                "branch_code" => Deserialize::begin(&mut self.branch_code),
84                "branch_name" => Deserialize::begin(&mut self.branch_name),
85                _ => <dyn Visitor>::ignore(),
86            })
87        }
88
89        fn deser_default() -> Self {
90            Self {
91                account_holder_address: Deserialize::default(),
92                account_holder_name: Deserialize::default(),
93                account_number: Deserialize::default(),
94                account_type: Deserialize::default(),
95                bank_address: Deserialize::default(),
96                bank_code: Deserialize::default(),
97                bank_name: Deserialize::default(),
98                branch_code: Deserialize::default(),
99                branch_name: Deserialize::default(),
100            }
101        }
102
103        fn take_out(&mut self) -> Option<Self::Out> {
104            let (
105                Some(account_holder_address),
106                Some(account_holder_name),
107                Some(account_number),
108                Some(account_type),
109                Some(bank_address),
110                Some(bank_code),
111                Some(bank_name),
112                Some(branch_code),
113                Some(branch_name),
114            ) = (
115                self.account_holder_address.take(),
116                self.account_holder_name.take(),
117                self.account_number.take(),
118                self.account_type.take(),
119                self.bank_address.take(),
120                self.bank_code.take(),
121                self.bank_name.take(),
122                self.branch_code.take(),
123                self.branch_name.take(),
124            )
125            else {
126                return None;
127            };
128            Some(Self::Out {
129                account_holder_address,
130                account_holder_name,
131                account_number,
132                account_type,
133                bank_address,
134                bank_code,
135                bank_name,
136                branch_code,
137                branch_name,
138            })
139        }
140    }
141
142    impl Map for Builder<'_> {
143        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
144            self.builder.key(k)
145        }
146
147        fn finish(&mut self) -> Result<()> {
148            *self.out = self.builder.take_out();
149            Ok(())
150        }
151    }
152
153    impl ObjectDeser for FundingInstructionsBankTransferZenginRecord {
154        type Builder = FundingInstructionsBankTransferZenginRecordBuilder;
155    }
156
157    impl FromValueOpt for FundingInstructionsBankTransferZenginRecord {
158        fn from_value(v: Value) -> Option<Self> {
159            let Value::Object(obj) = v else {
160                return None;
161            };
162            let mut b = FundingInstructionsBankTransferZenginRecordBuilder::deser_default();
163            for (k, v) in obj {
164                match k.as_str() {
165                    "account_holder_address" => {
166                        b.account_holder_address = FromValueOpt::from_value(v)
167                    }
168                    "account_holder_name" => b.account_holder_name = FromValueOpt::from_value(v),
169                    "account_number" => b.account_number = FromValueOpt::from_value(v),
170                    "account_type" => b.account_type = FromValueOpt::from_value(v),
171                    "bank_address" => b.bank_address = FromValueOpt::from_value(v),
172                    "bank_code" => b.bank_code = FromValueOpt::from_value(v),
173                    "bank_name" => b.bank_name = FromValueOpt::from_value(v),
174                    "branch_code" => b.branch_code = FromValueOpt::from_value(v),
175                    "branch_name" => b.branch_name = FromValueOpt::from_value(v),
176                    _ => {}
177                }
178            }
179            b.take_out()
180        }
181    }
182};
stripe_shared/funding_instructions_bank_transfer_zengin_record.rs

stripe_shared/
funding_instructions_bank_transfer_zengin_record.rs
