stripe_terminal/terminal_location/
types.rs

1/// A Location represents a grouping of readers.
2///
3/// Related guide: [Fleet management](https://stripe.com/docs/terminal/fleet/locations)
4///
5/// For more details see <<https://stripe.com/docs/api/terminal/locations/object>>.
6#[derive(Clone, Debug)]
7#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
8pub struct TerminalLocation {
9    pub address: stripe_shared::Address,
10    pub address_kana: Option<stripe_shared::LegalEntityJapanAddress>,
11    pub address_kanji: Option<stripe_shared::LegalEntityJapanAddress>,
12    /// The ID of a configuration that will be used to customize all readers in this location.
13    pub configuration_overrides: Option<String>,
14    /// The display name of the location.
15    pub display_name: String,
16    /// The Kana variation of the display name of the location.
17    pub display_name_kana: Option<String>,
18    /// The Kanji variation of the display name of the location.
19    pub display_name_kanji: Option<String>,
20    /// Unique identifier for the object.
21    pub id: stripe_terminal::TerminalLocationId,
22    /// Has the value `true` if the object exists in live mode or the value `false` if the object exists in test mode.
23    pub livemode: bool,
24    /// Set of [key-value pairs](https://stripe.com/docs/api/metadata) that you can attach to an object.
25    /// This can be useful for storing additional information about the object in a structured format.
26    pub metadata: std::collections::HashMap<String, String>,
27    /// The phone number of the location.
28    pub phone: Option<String>,
29}
30#[doc(hidden)]
31pub struct TerminalLocationBuilder {
32    address: Option<stripe_shared::Address>,
33    address_kana: Option<Option<stripe_shared::LegalEntityJapanAddress>>,
34    address_kanji: Option<Option<stripe_shared::LegalEntityJapanAddress>>,
35    configuration_overrides: Option<Option<String>>,
36    display_name: Option<String>,
37    display_name_kana: Option<Option<String>>,
38    display_name_kanji: Option<Option<String>>,
39    id: Option<stripe_terminal::TerminalLocationId>,
40    livemode: Option<bool>,
41    metadata: Option<std::collections::HashMap<String, String>>,
42    phone: Option<Option<String>>,
43}
44
45#[allow(
46    unused_variables,
47    irrefutable_let_patterns,
48    clippy::let_unit_value,
49    clippy::match_single_binding,
50    clippy::single_match
51)]
52const _: () = {
53    use miniserde::de::{Map, Visitor};
54    use miniserde::json::Value;
55    use miniserde::{Deserialize, Result, make_place};
56    use stripe_types::miniserde_helpers::FromValueOpt;
57    use stripe_types::{MapBuilder, ObjectDeser};
58
59    make_place!(Place);
60
61    impl Deserialize for TerminalLocation {
62        fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
63            Place::new(out)
64        }
65    }
66
67    struct Builder<'a> {
68        out: &'a mut Option<TerminalLocation>,
69        builder: TerminalLocationBuilder,
70    }
71
72    impl Visitor for Place<TerminalLocation> {
73        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
74            Ok(Box::new(Builder {
75                out: &mut self.out,
76                builder: TerminalLocationBuilder::deser_default(),
77            }))
78        }
79    }
80
81    impl MapBuilder for TerminalLocationBuilder {
82        type Out = TerminalLocation;
83        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
84            Ok(match k {
85                "address" => Deserialize::begin(&mut self.address),
86                "address_kana" => Deserialize::begin(&mut self.address_kana),
87                "address_kanji" => Deserialize::begin(&mut self.address_kanji),
88                "configuration_overrides" => Deserialize::begin(&mut self.configuration_overrides),
89                "display_name" => Deserialize::begin(&mut self.display_name),
90                "display_name_kana" => Deserialize::begin(&mut self.display_name_kana),
91                "display_name_kanji" => Deserialize::begin(&mut self.display_name_kanji),
92                "id" => Deserialize::begin(&mut self.id),
93                "livemode" => Deserialize::begin(&mut self.livemode),
94                "metadata" => Deserialize::begin(&mut self.metadata),
95                "phone" => Deserialize::begin(&mut self.phone),
96
97                _ => <dyn Visitor>::ignore(),
98            })
99        }
100
101        fn deser_default() -> Self {
102            Self {
103                address: Deserialize::default(),
104                address_kana: Deserialize::default(),
105                address_kanji: Deserialize::default(),
106                configuration_overrides: Deserialize::default(),
107                display_name: Deserialize::default(),
108                display_name_kana: Deserialize::default(),
109                display_name_kanji: Deserialize::default(),
110                id: Deserialize::default(),
111                livemode: Deserialize::default(),
112                metadata: Deserialize::default(),
113                phone: Deserialize::default(),
114            }
115        }
116
117        fn take_out(&mut self) -> Option<Self::Out> {
118            let (
119                Some(address),
120                Some(address_kana),
121                Some(address_kanji),
122                Some(configuration_overrides),
123                Some(display_name),
124                Some(display_name_kana),
125                Some(display_name_kanji),
126                Some(id),
127                Some(livemode),
128                Some(metadata),
129                Some(phone),
130            ) = (
131                self.address.take(),
132                self.address_kana.take(),
133                self.address_kanji.take(),
134                self.configuration_overrides.take(),
135                self.display_name.take(),
136                self.display_name_kana.take(),
137                self.display_name_kanji.take(),
138                self.id.take(),
139                self.livemode,
140                self.metadata.take(),
141                self.phone.take(),
142            )
143            else {
144                return None;
145            };
146            Some(Self::Out {
147                address,
148                address_kana,
149                address_kanji,
150                configuration_overrides,
151                display_name,
152                display_name_kana,
153                display_name_kanji,
154                id,
155                livemode,
156                metadata,
157                phone,
158            })
159        }
160    }
161
162    impl Map for Builder<'_> {
163        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
164            self.builder.key(k)
165        }
166
167        fn finish(&mut self) -> Result<()> {
168            *self.out = self.builder.take_out();
169            Ok(())
170        }
171    }
172
173    impl ObjectDeser for TerminalLocation {
174        type Builder = TerminalLocationBuilder;
175    }
176
177    impl FromValueOpt for TerminalLocation {
178        fn from_value(v: Value) -> Option<Self> {
179            let Value::Object(obj) = v else {
180                return None;
181            };
182            let mut b = TerminalLocationBuilder::deser_default();
183            for (k, v) in obj {
184                match k.as_str() {
185                    "address" => b.address = FromValueOpt::from_value(v),
186                    "address_kana" => b.address_kana = FromValueOpt::from_value(v),
187                    "address_kanji" => b.address_kanji = FromValueOpt::from_value(v),
188                    "configuration_overrides" => {
189                        b.configuration_overrides = FromValueOpt::from_value(v)
190                    }
191                    "display_name" => b.display_name = FromValueOpt::from_value(v),
192                    "display_name_kana" => b.display_name_kana = FromValueOpt::from_value(v),
193                    "display_name_kanji" => b.display_name_kanji = FromValueOpt::from_value(v),
194                    "id" => b.id = FromValueOpt::from_value(v),
195                    "livemode" => b.livemode = FromValueOpt::from_value(v),
196                    "metadata" => b.metadata = FromValueOpt::from_value(v),
197                    "phone" => b.phone = FromValueOpt::from_value(v),
198
199                    _ => {}
200                }
201            }
202            b.take_out()
203        }
204    }
205};
206#[cfg(feature = "serialize")]
207impl serde::Serialize for TerminalLocation {
208    fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
209        use serde::ser::SerializeStruct;
210        let mut s = s.serialize_struct("TerminalLocation", 12)?;
211        s.serialize_field("address", &self.address)?;
212        s.serialize_field("address_kana", &self.address_kana)?;
213        s.serialize_field("address_kanji", &self.address_kanji)?;
214        s.serialize_field("configuration_overrides", &self.configuration_overrides)?;
215        s.serialize_field("display_name", &self.display_name)?;
216        s.serialize_field("display_name_kana", &self.display_name_kana)?;
217        s.serialize_field("display_name_kanji", &self.display_name_kanji)?;
218        s.serialize_field("id", &self.id)?;
219        s.serialize_field("livemode", &self.livemode)?;
220        s.serialize_field("metadata", &self.metadata)?;
221        s.serialize_field("phone", &self.phone)?;
222
223        s.serialize_field("object", "terminal.location")?;
224        s.end()
225    }
226}
227impl stripe_types::Object for TerminalLocation {
228    type Id = stripe_terminal::TerminalLocationId;
229    fn id(&self) -> &Self::Id {
230        &self.id
231    }
232
233    fn into_id(self) -> Self::Id {
234        self.id
235    }
236}
237stripe_types::def_id!(TerminalLocationId);
stripe_terminal/terminal_location/types.rs

stripe_terminal/terminal_location/
types.rs
