stripe_shared/
file_link.rs

1/// To share the contents of a `File` object with non-Stripe users, you can
2/// create a `FileLink`. `FileLink`s contain a URL that you can use to
3/// retrieve the contents of the file without authentication.
4///
5/// For more details see <<https://stripe.com/docs/api/file_links/object>>.
6#[derive(Clone)]
7#[cfg_attr(not(feature = "redact-generated-debug"), derive(Debug))]
8#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
9pub struct FileLink {
10    /// Time at which the object was created. Measured in seconds since the Unix epoch.
11    pub created: stripe_types::Timestamp,
12    /// Returns if the link is already expired.
13    pub expired: bool,
14    /// Time that the link expires.
15    pub expires_at: Option<stripe_types::Timestamp>,
16    /// The file object this link points to.
17    pub file: stripe_types::Expandable<stripe_shared::File>,
18    /// Unique identifier for the object.
19    pub id: stripe_shared::FileLinkId,
20    /// If the object exists in live mode, the value is `true`.
21    /// If the object exists in test mode, the value is `false`.
22    pub livemode: bool,
23    /// Set of [key-value pairs](https://docs.stripe.com/api/metadata) that you can attach to an object.
24    /// This can be useful for storing additional information about the object in a structured format.
25    pub metadata: std::collections::HashMap<String, String>,
26    /// The publicly accessible URL to download the file.
27    pub url: Option<String>,
28}
29#[cfg(feature = "redact-generated-debug")]
30impl std::fmt::Debug for FileLink {
31    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
32        f.debug_struct("FileLink").finish_non_exhaustive()
33    }
34}
35#[doc(hidden)]
36pub struct FileLinkBuilder {
37    created: Option<stripe_types::Timestamp>,
38    expired: Option<bool>,
39    expires_at: Option<Option<stripe_types::Timestamp>>,
40    file: Option<stripe_types::Expandable<stripe_shared::File>>,
41    id: Option<stripe_shared::FileLinkId>,
42    livemode: Option<bool>,
43    metadata: Option<std::collections::HashMap<String, String>>,
44    url: Option<Option<String>>,
45}
46
47#[allow(
48    unused_variables,
49    irrefutable_let_patterns,
50    clippy::let_unit_value,
51    clippy::match_single_binding,
52    clippy::single_match
53)]
54const _: () = {
55    use miniserde::de::{Map, Visitor};
56    use miniserde::json::Value;
57    use miniserde::{Deserialize, Result, make_place};
58    use stripe_types::miniserde_helpers::FromValueOpt;
59    use stripe_types::{MapBuilder, ObjectDeser};
60
61    make_place!(Place);
62
63    impl Deserialize for FileLink {
64        fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
65            Place::new(out)
66        }
67    }
68
69    struct Builder<'a> {
70        out: &'a mut Option<FileLink>,
71        builder: FileLinkBuilder,
72    }
73
74    impl Visitor for Place<FileLink> {
75        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
76            Ok(Box::new(Builder { out: &mut self.out, builder: FileLinkBuilder::deser_default() }))
77        }
78    }
79
80    impl MapBuilder for FileLinkBuilder {
81        type Out = FileLink;
82        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
83            Ok(match k {
84                "created" => Deserialize::begin(&mut self.created),
85                "expired" => Deserialize::begin(&mut self.expired),
86                "expires_at" => Deserialize::begin(&mut self.expires_at),
87                "file" => Deserialize::begin(&mut self.file),
88                "id" => Deserialize::begin(&mut self.id),
89                "livemode" => Deserialize::begin(&mut self.livemode),
90                "metadata" => Deserialize::begin(&mut self.metadata),
91                "url" => Deserialize::begin(&mut self.url),
92                _ => <dyn Visitor>::ignore(),
93            })
94        }
95
96        fn deser_default() -> Self {
97            Self {
98                created: Deserialize::default(),
99                expired: Deserialize::default(),
100                expires_at: Deserialize::default(),
101                file: Deserialize::default(),
102                id: Deserialize::default(),
103                livemode: Deserialize::default(),
104                metadata: Deserialize::default(),
105                url: Deserialize::default(),
106            }
107        }
108
109        fn take_out(&mut self) -> Option<Self::Out> {
110            let (
111                Some(created),
112                Some(expired),
113                Some(expires_at),
114                Some(file),
115                Some(id),
116                Some(livemode),
117                Some(metadata),
118                Some(url),
119            ) = (
120                self.created,
121                self.expired,
122                self.expires_at,
123                self.file.take(),
124                self.id.take(),
125                self.livemode,
126                self.metadata.take(),
127                self.url.take(),
128            )
129            else {
130                return None;
131            };
132            Some(Self::Out { created, expired, expires_at, file, id, livemode, metadata, url })
133        }
134    }
135
136    impl Map for Builder<'_> {
137        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
138            self.builder.key(k)
139        }
140
141        fn finish(&mut self) -> Result<()> {
142            *self.out = self.builder.take_out();
143            Ok(())
144        }
145    }
146
147    impl ObjectDeser for FileLink {
148        type Builder = FileLinkBuilder;
149    }
150
151    impl FromValueOpt for FileLink {
152        fn from_value(v: Value) -> Option<Self> {
153            let Value::Object(obj) = v else {
154                return None;
155            };
156            let mut b = FileLinkBuilder::deser_default();
157            for (k, v) in obj {
158                match k.as_str() {
159                    "created" => b.created = FromValueOpt::from_value(v),
160                    "expired" => b.expired = FromValueOpt::from_value(v),
161                    "expires_at" => b.expires_at = FromValueOpt::from_value(v),
162                    "file" => b.file = FromValueOpt::from_value(v),
163                    "id" => b.id = FromValueOpt::from_value(v),
164                    "livemode" => b.livemode = FromValueOpt::from_value(v),
165                    "metadata" => b.metadata = FromValueOpt::from_value(v),
166                    "url" => b.url = FromValueOpt::from_value(v),
167                    _ => {}
168                }
169            }
170            b.take_out()
171        }
172    }
173};
174#[cfg(feature = "serialize")]
175impl serde::Serialize for FileLink {
176    fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
177        use serde::ser::SerializeStruct;
178        let mut s = s.serialize_struct("FileLink", 9)?;
179        s.serialize_field("created", &self.created)?;
180        s.serialize_field("expired", &self.expired)?;
181        s.serialize_field("expires_at", &self.expires_at)?;
182        s.serialize_field("file", &self.file)?;
183        s.serialize_field("id", &self.id)?;
184        s.serialize_field("livemode", &self.livemode)?;
185        s.serialize_field("metadata", &self.metadata)?;
186        s.serialize_field("url", &self.url)?;
187
188        s.serialize_field("object", "file_link")?;
189        s.end()
190    }
191}
192impl stripe_types::Object for FileLink {
193    type Id = stripe_shared::FileLinkId;
194    fn id(&self) -> &Self::Id {
195        &self.id
196    }
197
198    fn into_id(self) -> Self::Id {
199        self.id
200    }
201}
202stripe_types::def_id!(FileLinkId);
stripe_shared/file_link.rs

stripe_shared/
file_link.rs
