stripe_shared/
payment_link.rs

1/// A payment link is a shareable URL that will take your customers to a hosted payment page.
2/// A payment link can be shared and used multiple times.
3///
4/// When a customer opens a payment link it will open a new [checkout session](https://stripe.com/docs/api/checkout/sessions) to render the payment page.
5/// You can use [checkout session events](https://stripe.com/docs/api/events/types#event_types-checkout.session.completed) to track payments through payment links.
6///
7/// Related guide: [Payment Links API](https://stripe.com/docs/payment-links)
8///
9/// For more details see <<https://stripe.com/docs/api/payment_links/payment_links/object>>.
10#[derive(Clone, Debug)]
11#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
12pub struct PaymentLink {
13    /// Whether the payment link's `url` is active.
14    /// If `false`, customers visiting the URL will be shown a page saying that the link has been deactivated.
15    pub active: bool,
16    pub after_completion: stripe_shared::PaymentLinksResourceAfterCompletion,
17    /// Whether user redeemable promotion codes are enabled.
18    pub allow_promotion_codes: bool,
19    /// The ID of the Connect application that created the Payment Link.
20    pub application: Option<stripe_types::Expandable<stripe_shared::Application>>,
21    /// The amount of the application fee (if any) that will be requested to be applied to the payment and transferred to the application owner's Stripe account.
22    pub application_fee_amount: Option<i64>,
23    /// This represents the percentage of the subscription invoice total that will be transferred to the application owner's Stripe account.
24    pub application_fee_percent: Option<f64>,
25    pub automatic_tax: stripe_shared::PaymentLinksResourceAutomaticTax,
26    /// Configuration for collecting the customer's billing address. Defaults to `auto`.
27    pub billing_address_collection: stripe_shared::PaymentLinkBillingAddressCollection,
28    /// When set, provides configuration to gather active consent from customers.
29    pub consent_collection: Option<stripe_shared::PaymentLinksResourceConsentCollection>,
30    /// Three-letter [ISO currency code](https://www.iso.org/iso-4217-currency-codes.html), in lowercase.
31    /// Must be a [supported currency](https://stripe.com/docs/currencies).
32    pub currency: stripe_types::Currency,
33    /// Collect additional information from your customer using custom fields.
34    /// Up to 3 fields are supported.
35    pub custom_fields: Vec<stripe_shared::PaymentLinksResourceCustomFields>,
36    pub custom_text: stripe_shared::PaymentLinksResourceCustomText,
37    /// Configuration for Customer creation during checkout.
38    pub customer_creation: PaymentLinkCustomerCreation,
39    /// Unique identifier for the object.
40    pub id: stripe_shared::PaymentLinkId,
41    /// The custom message to be displayed to a customer when a payment link is no longer active.
42    pub inactive_message: Option<String>,
43    /// Configuration for creating invoice for payment mode payment links.
44    pub invoice_creation: Option<stripe_shared::PaymentLinksResourceInvoiceCreation>,
45    /// The line items representing what is being sold.
46    pub line_items: Option<stripe_types::List<stripe_shared::CheckoutSessionItem>>,
47    /// Has the value `true` if the object exists in live mode or the value `false` if the object exists in test mode.
48    pub livemode: bool,
49    /// Set of [key-value pairs](https://stripe.com/docs/api/metadata) that you can attach to an object.
50    /// This can be useful for storing additional information about the object in a structured format.
51    pub metadata: std::collections::HashMap<String, String>,
52    pub name_collection: Option<stripe_shared::PaymentLinksResourceNameCollection>,
53    /// The account on behalf of which to charge.
54    /// See the [Connect documentation](https://support.stripe.com/questions/sending-invoices-on-behalf-of-connected-accounts) for details.
55    pub on_behalf_of: Option<stripe_types::Expandable<stripe_shared::Account>>,
56    /// The optional items presented to the customer at checkout.
57    pub optional_items: Option<Vec<stripe_shared::PaymentLinksResourceOptionalItem>>,
58    /// Indicates the parameters to be passed to PaymentIntent creation during checkout.
59    pub payment_intent_data: Option<stripe_shared::PaymentLinksResourcePaymentIntentData>,
60    /// Configuration for collecting a payment method during checkout. Defaults to `always`.
61    pub payment_method_collection: PaymentLinkPaymentMethodCollection,
62    /// The list of payment method types that customers can use.
63    /// When `null`, Stripe will dynamically show relevant payment methods you've enabled in your [payment method settings](https://dashboard.stripe.com/settings/payment_methods).
64    pub payment_method_types: Option<Vec<stripe_shared::PaymentLinkPaymentMethodTypes>>,
65    pub phone_number_collection: stripe_shared::PaymentLinksResourcePhoneNumberCollection,
66    /// Settings that restrict the usage of a payment link.
67    pub restrictions: Option<stripe_shared::PaymentLinksResourceRestrictions>,
68    /// Configuration for collecting the customer's shipping address.
69    pub shipping_address_collection:
70        Option<stripe_shared::PaymentLinksResourceShippingAddressCollection>,
71    /// The shipping rate options applied to the session.
72    pub shipping_options: Vec<stripe_shared::PaymentLinksResourceShippingOption>,
73    /// Indicates the type of transaction being performed which customizes relevant text on the page, such as the submit button.
74    pub submit_type: stripe_shared::PaymentLinkSubmitType,
75    /// When creating a subscription, the specified configuration data will be used.
76    /// There must be at least one line item with a recurring price to use `subscription_data`.
77    pub subscription_data: Option<stripe_shared::PaymentLinksResourceSubscriptionData>,
78    pub tax_id_collection: stripe_shared::PaymentLinksResourceTaxIdCollection,
79    /// The account (if any) the payments will be attributed to for tax reporting, and where funds from each payment will be transferred to.
80    pub transfer_data: Option<stripe_shared::PaymentLinksResourceTransferData>,
81    /// The public URL that can be shared with customers.
82    pub url: String,
83}
84#[doc(hidden)]
85pub struct PaymentLinkBuilder {
86    active: Option<bool>,
87    after_completion: Option<stripe_shared::PaymentLinksResourceAfterCompletion>,
88    allow_promotion_codes: Option<bool>,
89    application: Option<Option<stripe_types::Expandable<stripe_shared::Application>>>,
90    application_fee_amount: Option<Option<i64>>,
91    application_fee_percent: Option<Option<f64>>,
92    automatic_tax: Option<stripe_shared::PaymentLinksResourceAutomaticTax>,
93    billing_address_collection: Option<stripe_shared::PaymentLinkBillingAddressCollection>,
94    consent_collection: Option<Option<stripe_shared::PaymentLinksResourceConsentCollection>>,
95    currency: Option<stripe_types::Currency>,
96    custom_fields: Option<Vec<stripe_shared::PaymentLinksResourceCustomFields>>,
97    custom_text: Option<stripe_shared::PaymentLinksResourceCustomText>,
98    customer_creation: Option<PaymentLinkCustomerCreation>,
99    id: Option<stripe_shared::PaymentLinkId>,
100    inactive_message: Option<Option<String>>,
101    invoice_creation: Option<Option<stripe_shared::PaymentLinksResourceInvoiceCreation>>,
102    line_items: Option<Option<stripe_types::List<stripe_shared::CheckoutSessionItem>>>,
103    livemode: Option<bool>,
104    metadata: Option<std::collections::HashMap<String, String>>,
105    name_collection: Option<Option<stripe_shared::PaymentLinksResourceNameCollection>>,
106    on_behalf_of: Option<Option<stripe_types::Expandable<stripe_shared::Account>>>,
107    optional_items: Option<Option<Vec<stripe_shared::PaymentLinksResourceOptionalItem>>>,
108    payment_intent_data: Option<Option<stripe_shared::PaymentLinksResourcePaymentIntentData>>,
109    payment_method_collection: Option<PaymentLinkPaymentMethodCollection>,
110    payment_method_types: Option<Option<Vec<stripe_shared::PaymentLinkPaymentMethodTypes>>>,
111    phone_number_collection: Option<stripe_shared::PaymentLinksResourcePhoneNumberCollection>,
112    restrictions: Option<Option<stripe_shared::PaymentLinksResourceRestrictions>>,
113    shipping_address_collection:
114        Option<Option<stripe_shared::PaymentLinksResourceShippingAddressCollection>>,
115    shipping_options: Option<Vec<stripe_shared::PaymentLinksResourceShippingOption>>,
116    submit_type: Option<stripe_shared::PaymentLinkSubmitType>,
117    subscription_data: Option<Option<stripe_shared::PaymentLinksResourceSubscriptionData>>,
118    tax_id_collection: Option<stripe_shared::PaymentLinksResourceTaxIdCollection>,
119    transfer_data: Option<Option<stripe_shared::PaymentLinksResourceTransferData>>,
120    url: Option<String>,
121}
122
123#[allow(
124    unused_variables,
125    irrefutable_let_patterns,
126    clippy::let_unit_value,
127    clippy::match_single_binding,
128    clippy::single_match
129)]
130const _: () = {
131    use miniserde::de::{Map, Visitor};
132    use miniserde::json::Value;
133    use miniserde::{Deserialize, Result, make_place};
134    use stripe_types::miniserde_helpers::FromValueOpt;
135    use stripe_types::{MapBuilder, ObjectDeser};
136
137    make_place!(Place);
138
139    impl Deserialize for PaymentLink {
140        fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
141            Place::new(out)
142        }
143    }
144
145    struct Builder<'a> {
146        out: &'a mut Option<PaymentLink>,
147        builder: PaymentLinkBuilder,
148    }
149
150    impl Visitor for Place<PaymentLink> {
151        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
152            Ok(Box::new(Builder {
153                out: &mut self.out,
154                builder: PaymentLinkBuilder::deser_default(),
155            }))
156        }
157    }
158
159    impl MapBuilder for PaymentLinkBuilder {
160        type Out = PaymentLink;
161        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
162            Ok(match k {
163                "active" => Deserialize::begin(&mut self.active),
164                "after_completion" => Deserialize::begin(&mut self.after_completion),
165                "allow_promotion_codes" => Deserialize::begin(&mut self.allow_promotion_codes),
166                "application" => Deserialize::begin(&mut self.application),
167                "application_fee_amount" => Deserialize::begin(&mut self.application_fee_amount),
168                "application_fee_percent" => Deserialize::begin(&mut self.application_fee_percent),
169                "automatic_tax" => Deserialize::begin(&mut self.automatic_tax),
170                "billing_address_collection" => {
171                    Deserialize::begin(&mut self.billing_address_collection)
172                }
173                "consent_collection" => Deserialize::begin(&mut self.consent_collection),
174                "currency" => Deserialize::begin(&mut self.currency),
175                "custom_fields" => Deserialize::begin(&mut self.custom_fields),
176                "custom_text" => Deserialize::begin(&mut self.custom_text),
177                "customer_creation" => Deserialize::begin(&mut self.customer_creation),
178                "id" => Deserialize::begin(&mut self.id),
179                "inactive_message" => Deserialize::begin(&mut self.inactive_message),
180                "invoice_creation" => Deserialize::begin(&mut self.invoice_creation),
181                "line_items" => Deserialize::begin(&mut self.line_items),
182                "livemode" => Deserialize::begin(&mut self.livemode),
183                "metadata" => Deserialize::begin(&mut self.metadata),
184                "name_collection" => Deserialize::begin(&mut self.name_collection),
185                "on_behalf_of" => Deserialize::begin(&mut self.on_behalf_of),
186                "optional_items" => Deserialize::begin(&mut self.optional_items),
187                "payment_intent_data" => Deserialize::begin(&mut self.payment_intent_data),
188                "payment_method_collection" => {
189                    Deserialize::begin(&mut self.payment_method_collection)
190                }
191                "payment_method_types" => Deserialize::begin(&mut self.payment_method_types),
192                "phone_number_collection" => Deserialize::begin(&mut self.phone_number_collection),
193                "restrictions" => Deserialize::begin(&mut self.restrictions),
194                "shipping_address_collection" => {
195                    Deserialize::begin(&mut self.shipping_address_collection)
196                }
197                "shipping_options" => Deserialize::begin(&mut self.shipping_options),
198                "submit_type" => Deserialize::begin(&mut self.submit_type),
199                "subscription_data" => Deserialize::begin(&mut self.subscription_data),
200                "tax_id_collection" => Deserialize::begin(&mut self.tax_id_collection),
201                "transfer_data" => Deserialize::begin(&mut self.transfer_data),
202                "url" => Deserialize::begin(&mut self.url),
203                _ => <dyn Visitor>::ignore(),
204            })
205        }
206
207        fn deser_default() -> Self {
208            Self {
209                active: Deserialize::default(),
210                after_completion: Deserialize::default(),
211                allow_promotion_codes: Deserialize::default(),
212                application: Deserialize::default(),
213                application_fee_amount: Deserialize::default(),
214                application_fee_percent: Deserialize::default(),
215                automatic_tax: Deserialize::default(),
216                billing_address_collection: Deserialize::default(),
217                consent_collection: Deserialize::default(),
218                currency: Deserialize::default(),
219                custom_fields: Deserialize::default(),
220                custom_text: Deserialize::default(),
221                customer_creation: Deserialize::default(),
222                id: Deserialize::default(),
223                inactive_message: Deserialize::default(),
224                invoice_creation: Deserialize::default(),
225                line_items: Deserialize::default(),
226                livemode: Deserialize::default(),
227                metadata: Deserialize::default(),
228                name_collection: Deserialize::default(),
229                on_behalf_of: Deserialize::default(),
230                optional_items: Deserialize::default(),
231                payment_intent_data: Deserialize::default(),
232                payment_method_collection: Deserialize::default(),
233                payment_method_types: Deserialize::default(),
234                phone_number_collection: Deserialize::default(),
235                restrictions: Deserialize::default(),
236                shipping_address_collection: Deserialize::default(),
237                shipping_options: Deserialize::default(),
238                submit_type: Deserialize::default(),
239                subscription_data: Deserialize::default(),
240                tax_id_collection: Deserialize::default(),
241                transfer_data: Deserialize::default(),
242                url: Deserialize::default(),
243            }
244        }
245
246        fn take_out(&mut self) -> Option<Self::Out> {
247            let (
248                Some(active),
249                Some(after_completion),
250                Some(allow_promotion_codes),
251                Some(application),
252                Some(application_fee_amount),
253                Some(application_fee_percent),
254                Some(automatic_tax),
255                Some(billing_address_collection),
256                Some(consent_collection),
257                Some(currency),
258                Some(custom_fields),
259                Some(custom_text),
260                Some(customer_creation),
261                Some(id),
262                Some(inactive_message),
263                Some(invoice_creation),
264                Some(line_items),
265                Some(livemode),
266                Some(metadata),
267                Some(name_collection),
268                Some(on_behalf_of),
269                Some(optional_items),
270                Some(payment_intent_data),
271                Some(payment_method_collection),
272                Some(payment_method_types),
273                Some(phone_number_collection),
274                Some(restrictions),
275                Some(shipping_address_collection),
276                Some(shipping_options),
277                Some(submit_type),
278                Some(subscription_data),
279                Some(tax_id_collection),
280                Some(transfer_data),
281                Some(url),
282            ) = (
283                self.active,
284                self.after_completion.take(),
285                self.allow_promotion_codes,
286                self.application.take(),
287                self.application_fee_amount,
288                self.application_fee_percent,
289                self.automatic_tax.take(),
290                self.billing_address_collection.take(),
291                self.consent_collection.take(),
292                self.currency.take(),
293                self.custom_fields.take(),
294                self.custom_text.take(),
295                self.customer_creation.take(),
296                self.id.take(),
297                self.inactive_message.take(),
298                self.invoice_creation.take(),
299                self.line_items.take(),
300                self.livemode,
301                self.metadata.take(),
302                self.name_collection,
303                self.on_behalf_of.take(),
304                self.optional_items.take(),
305                self.payment_intent_data.take(),
306                self.payment_method_collection.take(),
307                self.payment_method_types.take(),
308                self.phone_number_collection,
309                self.restrictions,
310                self.shipping_address_collection.take(),
311                self.shipping_options.take(),
312                self.submit_type.take(),
313                self.subscription_data.take(),
314                self.tax_id_collection.take(),
315                self.transfer_data.take(),
316                self.url.take(),
317            )
318            else {
319                return None;
320            };
321            Some(Self::Out {
322                active,
323                after_completion,
324                allow_promotion_codes,
325                application,
326                application_fee_amount,
327                application_fee_percent,
328                automatic_tax,
329                billing_address_collection,
330                consent_collection,
331                currency,
332                custom_fields,
333                custom_text,
334                customer_creation,
335                id,
336                inactive_message,
337                invoice_creation,
338                line_items,
339                livemode,
340                metadata,
341                name_collection,
342                on_behalf_of,
343                optional_items,
344                payment_intent_data,
345                payment_method_collection,
346                payment_method_types,
347                phone_number_collection,
348                restrictions,
349                shipping_address_collection,
350                shipping_options,
351                submit_type,
352                subscription_data,
353                tax_id_collection,
354                transfer_data,
355                url,
356            })
357        }
358    }
359
360    impl Map for Builder<'_> {
361        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
362            self.builder.key(k)
363        }
364
365        fn finish(&mut self) -> Result<()> {
366            *self.out = self.builder.take_out();
367            Ok(())
368        }
369    }
370
371    impl ObjectDeser for PaymentLink {
372        type Builder = PaymentLinkBuilder;
373    }
374
375    impl FromValueOpt for PaymentLink {
376        fn from_value(v: Value) -> Option<Self> {
377            let Value::Object(obj) = v else {
378                return None;
379            };
380            let mut b = PaymentLinkBuilder::deser_default();
381            for (k, v) in obj {
382                match k.as_str() {
383                    "active" => b.active = FromValueOpt::from_value(v),
384                    "after_completion" => b.after_completion = FromValueOpt::from_value(v),
385                    "allow_promotion_codes" => {
386                        b.allow_promotion_codes = FromValueOpt::from_value(v)
387                    }
388                    "application" => b.application = FromValueOpt::from_value(v),
389                    "application_fee_amount" => {
390                        b.application_fee_amount = FromValueOpt::from_value(v)
391                    }
392                    "application_fee_percent" => {
393                        b.application_fee_percent = FromValueOpt::from_value(v)
394                    }
395                    "automatic_tax" => b.automatic_tax = FromValueOpt::from_value(v),
396                    "billing_address_collection" => {
397                        b.billing_address_collection = FromValueOpt::from_value(v)
398                    }
399                    "consent_collection" => b.consent_collection = FromValueOpt::from_value(v),
400                    "currency" => b.currency = FromValueOpt::from_value(v),
401                    "custom_fields" => b.custom_fields = FromValueOpt::from_value(v),
402                    "custom_text" => b.custom_text = FromValueOpt::from_value(v),
403                    "customer_creation" => b.customer_creation = FromValueOpt::from_value(v),
404                    "id" => b.id = FromValueOpt::from_value(v),
405                    "inactive_message" => b.inactive_message = FromValueOpt::from_value(v),
406                    "invoice_creation" => b.invoice_creation = FromValueOpt::from_value(v),
407                    "line_items" => b.line_items = FromValueOpt::from_value(v),
408                    "livemode" => b.livemode = FromValueOpt::from_value(v),
409                    "metadata" => b.metadata = FromValueOpt::from_value(v),
410                    "name_collection" => b.name_collection = FromValueOpt::from_value(v),
411                    "on_behalf_of" => b.on_behalf_of = FromValueOpt::from_value(v),
412                    "optional_items" => b.optional_items = FromValueOpt::from_value(v),
413                    "payment_intent_data" => b.payment_intent_data = FromValueOpt::from_value(v),
414                    "payment_method_collection" => {
415                        b.payment_method_collection = FromValueOpt::from_value(v)
416                    }
417                    "payment_method_types" => b.payment_method_types = FromValueOpt::from_value(v),
418                    "phone_number_collection" => {
419                        b.phone_number_collection = FromValueOpt::from_value(v)
420                    }
421                    "restrictions" => b.restrictions = FromValueOpt::from_value(v),
422                    "shipping_address_collection" => {
423                        b.shipping_address_collection = FromValueOpt::from_value(v)
424                    }
425                    "shipping_options" => b.shipping_options = FromValueOpt::from_value(v),
426                    "submit_type" => b.submit_type = FromValueOpt::from_value(v),
427                    "subscription_data" => b.subscription_data = FromValueOpt::from_value(v),
428                    "tax_id_collection" => b.tax_id_collection = FromValueOpt::from_value(v),
429                    "transfer_data" => b.transfer_data = FromValueOpt::from_value(v),
430                    "url" => b.url = FromValueOpt::from_value(v),
431                    _ => {}
432                }
433            }
434            b.take_out()
435        }
436    }
437};
438#[cfg(feature = "serialize")]
439impl serde::Serialize for PaymentLink {
440    fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
441        use serde::ser::SerializeStruct;
442        let mut s = s.serialize_struct("PaymentLink", 35)?;
443        s.serialize_field("active", &self.active)?;
444        s.serialize_field("after_completion", &self.after_completion)?;
445        s.serialize_field("allow_promotion_codes", &self.allow_promotion_codes)?;
446        s.serialize_field("application", &self.application)?;
447        s.serialize_field("application_fee_amount", &self.application_fee_amount)?;
448        s.serialize_field("application_fee_percent", &self.application_fee_percent)?;
449        s.serialize_field("automatic_tax", &self.automatic_tax)?;
450        s.serialize_field("billing_address_collection", &self.billing_address_collection)?;
451        s.serialize_field("consent_collection", &self.consent_collection)?;
452        s.serialize_field("currency", &self.currency)?;
453        s.serialize_field("custom_fields", &self.custom_fields)?;
454        s.serialize_field("custom_text", &self.custom_text)?;
455        s.serialize_field("customer_creation", &self.customer_creation)?;
456        s.serialize_field("id", &self.id)?;
457        s.serialize_field("inactive_message", &self.inactive_message)?;
458        s.serialize_field("invoice_creation", &self.invoice_creation)?;
459        s.serialize_field("line_items", &self.line_items)?;
460        s.serialize_field("livemode", &self.livemode)?;
461        s.serialize_field("metadata", &self.metadata)?;
462        s.serialize_field("name_collection", &self.name_collection)?;
463        s.serialize_field("on_behalf_of", &self.on_behalf_of)?;
464        s.serialize_field("optional_items", &self.optional_items)?;
465        s.serialize_field("payment_intent_data", &self.payment_intent_data)?;
466        s.serialize_field("payment_method_collection", &self.payment_method_collection)?;
467        s.serialize_field("payment_method_types", &self.payment_method_types)?;
468        s.serialize_field("phone_number_collection", &self.phone_number_collection)?;
469        s.serialize_field("restrictions", &self.restrictions)?;
470        s.serialize_field("shipping_address_collection", &self.shipping_address_collection)?;
471        s.serialize_field("shipping_options", &self.shipping_options)?;
472        s.serialize_field("submit_type", &self.submit_type)?;
473        s.serialize_field("subscription_data", &self.subscription_data)?;
474        s.serialize_field("tax_id_collection", &self.tax_id_collection)?;
475        s.serialize_field("transfer_data", &self.transfer_data)?;
476        s.serialize_field("url", &self.url)?;
477
478        s.serialize_field("object", "payment_link")?;
479        s.end()
480    }
481}
482/// Configuration for Customer creation during checkout.
483#[derive(Clone, Eq, PartialEq)]
484#[non_exhaustive]
485pub enum PaymentLinkCustomerCreation {
486    Always,
487    IfRequired,
488    /// An unrecognized value from Stripe. Should not be used as a request parameter.
489    Unknown(String),
490}
491impl PaymentLinkCustomerCreation {
492    pub fn as_str(&self) -> &str {
493        use PaymentLinkCustomerCreation::*;
494        match self {
495            Always => "always",
496            IfRequired => "if_required",
497            Unknown(v) => v,
498        }
499    }
500}
501
502impl std::str::FromStr for PaymentLinkCustomerCreation {
503    type Err = std::convert::Infallible;
504    fn from_str(s: &str) -> Result<Self, Self::Err> {
505        use PaymentLinkCustomerCreation::*;
506        match s {
507            "always" => Ok(Always),
508            "if_required" => Ok(IfRequired),
509            v => {
510                tracing::warn!(
511                    "Unknown value '{}' for enum '{}'",
512                    v,
513                    "PaymentLinkCustomerCreation"
514                );
515                Ok(Unknown(v.to_owned()))
516            }
517        }
518    }
519}
520impl std::fmt::Display for PaymentLinkCustomerCreation {
521    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
522        f.write_str(self.as_str())
523    }
524}
525
526impl std::fmt::Debug for PaymentLinkCustomerCreation {
527    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
528        f.write_str(self.as_str())
529    }
530}
531#[cfg(feature = "serialize")]
532impl serde::Serialize for PaymentLinkCustomerCreation {
533    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
534    where
535        S: serde::Serializer,
536    {
537        serializer.serialize_str(self.as_str())
538    }
539}
540impl miniserde::Deserialize for PaymentLinkCustomerCreation {
541    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
542        crate::Place::new(out)
543    }
544}
545
546impl miniserde::de::Visitor for crate::Place<PaymentLinkCustomerCreation> {
547    fn string(&mut self, s: &str) -> miniserde::Result<()> {
548        use std::str::FromStr;
549        self.out = Some(PaymentLinkCustomerCreation::from_str(s).expect("infallible"));
550        Ok(())
551    }
552}
553
554stripe_types::impl_from_val_with_from_str!(PaymentLinkCustomerCreation);
555#[cfg(feature = "deserialize")]
556impl<'de> serde::Deserialize<'de> for PaymentLinkCustomerCreation {
557    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
558        use std::str::FromStr;
559        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
560        Ok(Self::from_str(&s).expect("infallible"))
561    }
562}
563/// Configuration for collecting a payment method during checkout. Defaults to `always`.
564#[derive(Clone, Eq, PartialEq)]
565#[non_exhaustive]
566pub enum PaymentLinkPaymentMethodCollection {
567    Always,
568    IfRequired,
569    /// An unrecognized value from Stripe. Should not be used as a request parameter.
570    Unknown(String),
571}
572impl PaymentLinkPaymentMethodCollection {
573    pub fn as_str(&self) -> &str {
574        use PaymentLinkPaymentMethodCollection::*;
575        match self {
576            Always => "always",
577            IfRequired => "if_required",
578            Unknown(v) => v,
579        }
580    }
581}
582
583impl std::str::FromStr for PaymentLinkPaymentMethodCollection {
584    type Err = std::convert::Infallible;
585    fn from_str(s: &str) -> Result<Self, Self::Err> {
586        use PaymentLinkPaymentMethodCollection::*;
587        match s {
588            "always" => Ok(Always),
589            "if_required" => Ok(IfRequired),
590            v => {
591                tracing::warn!(
592                    "Unknown value '{}' for enum '{}'",
593                    v,
594                    "PaymentLinkPaymentMethodCollection"
595                );
596                Ok(Unknown(v.to_owned()))
597            }
598        }
599    }
600}
601impl std::fmt::Display for PaymentLinkPaymentMethodCollection {
602    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
603        f.write_str(self.as_str())
604    }
605}
606
607impl std::fmt::Debug for PaymentLinkPaymentMethodCollection {
608    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
609        f.write_str(self.as_str())
610    }
611}
612#[cfg(feature = "serialize")]
613impl serde::Serialize for PaymentLinkPaymentMethodCollection {
614    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
615    where
616        S: serde::Serializer,
617    {
618        serializer.serialize_str(self.as_str())
619    }
620}
621impl miniserde::Deserialize for PaymentLinkPaymentMethodCollection {
622    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
623        crate::Place::new(out)
624    }
625}
626
627impl miniserde::de::Visitor for crate::Place<PaymentLinkPaymentMethodCollection> {
628    fn string(&mut self, s: &str) -> miniserde::Result<()> {
629        use std::str::FromStr;
630        self.out = Some(PaymentLinkPaymentMethodCollection::from_str(s).expect("infallible"));
631        Ok(())
632    }
633}
634
635stripe_types::impl_from_val_with_from_str!(PaymentLinkPaymentMethodCollection);
636#[cfg(feature = "deserialize")]
637impl<'de> serde::Deserialize<'de> for PaymentLinkPaymentMethodCollection {
638    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
639        use std::str::FromStr;
640        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
641        Ok(Self::from_str(&s).expect("infallible"))
642    }
643}
644impl stripe_types::Object for PaymentLink {
645    type Id = stripe_shared::PaymentLinkId;
646    fn id(&self) -> &Self::Id {
647        &self.id
648    }
649
650    fn into_id(self) -> Self::Id {
651        self.id
652    }
653}
654stripe_types::def_id!(PaymentLinkId);
655#[derive(Clone, Eq, PartialEq)]
656#[non_exhaustive]
657pub enum PaymentLinkBillingAddressCollection {
658    Auto,
659    Required,
660    /// An unrecognized value from Stripe. Should not be used as a request parameter.
661    Unknown(String),
662}
663impl PaymentLinkBillingAddressCollection {
664    pub fn as_str(&self) -> &str {
665        use PaymentLinkBillingAddressCollection::*;
666        match self {
667            Auto => "auto",
668            Required => "required",
669            Unknown(v) => v,
670        }
671    }
672}
673
674impl std::str::FromStr for PaymentLinkBillingAddressCollection {
675    type Err = std::convert::Infallible;
676    fn from_str(s: &str) -> Result<Self, Self::Err> {
677        use PaymentLinkBillingAddressCollection::*;
678        match s {
679            "auto" => Ok(Auto),
680            "required" => Ok(Required),
681            v => {
682                tracing::warn!(
683                    "Unknown value '{}' for enum '{}'",
684                    v,
685                    "PaymentLinkBillingAddressCollection"
686                );
687                Ok(Unknown(v.to_owned()))
688            }
689        }
690    }
691}
692impl std::fmt::Display for PaymentLinkBillingAddressCollection {
693    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
694        f.write_str(self.as_str())
695    }
696}
697
698impl std::fmt::Debug for PaymentLinkBillingAddressCollection {
699    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
700        f.write_str(self.as_str())
701    }
702}
703impl serde::Serialize for PaymentLinkBillingAddressCollection {
704    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
705    where
706        S: serde::Serializer,
707    {
708        serializer.serialize_str(self.as_str())
709    }
710}
711impl miniserde::Deserialize for PaymentLinkBillingAddressCollection {
712    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
713        crate::Place::new(out)
714    }
715}
716
717impl miniserde::de::Visitor for crate::Place<PaymentLinkBillingAddressCollection> {
718    fn string(&mut self, s: &str) -> miniserde::Result<()> {
719        use std::str::FromStr;
720        self.out = Some(PaymentLinkBillingAddressCollection::from_str(s).expect("infallible"));
721        Ok(())
722    }
723}
724
725stripe_types::impl_from_val_with_from_str!(PaymentLinkBillingAddressCollection);
726#[cfg(feature = "deserialize")]
727impl<'de> serde::Deserialize<'de> for PaymentLinkBillingAddressCollection {
728    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
729        use std::str::FromStr;
730        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
731        Ok(Self::from_str(&s).expect("infallible"))
732    }
733}
734#[derive(Clone, Eq, PartialEq)]
735#[non_exhaustive]
736pub enum PaymentLinkPaymentMethodTypes {
737    Affirm,
738    AfterpayClearpay,
739    Alipay,
740    Alma,
741    AuBecsDebit,
742    BacsDebit,
743    Bancontact,
744    Billie,
745    Blik,
746    Boleto,
747    Card,
748    Cashapp,
749    Eps,
750    Fpx,
751    Giropay,
752    Grabpay,
753    Ideal,
754    Klarna,
755    Konbini,
756    Link,
757    MbWay,
758    Mobilepay,
759    Multibanco,
760    Oxxo,
761    P24,
762    PayByBank,
763    Paynow,
764    Paypal,
765    Pix,
766    Promptpay,
767    Satispay,
768    SepaDebit,
769    Sofort,
770    Swish,
771    Twint,
772    UsBankAccount,
773    WechatPay,
774    Zip,
775    /// An unrecognized value from Stripe. Should not be used as a request parameter.
776    Unknown(String),
777}
778impl PaymentLinkPaymentMethodTypes {
779    pub fn as_str(&self) -> &str {
780        use PaymentLinkPaymentMethodTypes::*;
781        match self {
782            Affirm => "affirm",
783            AfterpayClearpay => "afterpay_clearpay",
784            Alipay => "alipay",
785            Alma => "alma",
786            AuBecsDebit => "au_becs_debit",
787            BacsDebit => "bacs_debit",
788            Bancontact => "bancontact",
789            Billie => "billie",
790            Blik => "blik",
791            Boleto => "boleto",
792            Card => "card",
793            Cashapp => "cashapp",
794            Eps => "eps",
795            Fpx => "fpx",
796            Giropay => "giropay",
797            Grabpay => "grabpay",
798            Ideal => "ideal",
799            Klarna => "klarna",
800            Konbini => "konbini",
801            Link => "link",
802            MbWay => "mb_way",
803            Mobilepay => "mobilepay",
804            Multibanco => "multibanco",
805            Oxxo => "oxxo",
806            P24 => "p24",
807            PayByBank => "pay_by_bank",
808            Paynow => "paynow",
809            Paypal => "paypal",
810            Pix => "pix",
811            Promptpay => "promptpay",
812            Satispay => "satispay",
813            SepaDebit => "sepa_debit",
814            Sofort => "sofort",
815            Swish => "swish",
816            Twint => "twint",
817            UsBankAccount => "us_bank_account",
818            WechatPay => "wechat_pay",
819            Zip => "zip",
820            Unknown(v) => v,
821        }
822    }
823}
824
825impl std::str::FromStr for PaymentLinkPaymentMethodTypes {
826    type Err = std::convert::Infallible;
827    fn from_str(s: &str) -> Result<Self, Self::Err> {
828        use PaymentLinkPaymentMethodTypes::*;
829        match s {
830            "affirm" => Ok(Affirm),
831            "afterpay_clearpay" => Ok(AfterpayClearpay),
832            "alipay" => Ok(Alipay),
833            "alma" => Ok(Alma),
834            "au_becs_debit" => Ok(AuBecsDebit),
835            "bacs_debit" => Ok(BacsDebit),
836            "bancontact" => Ok(Bancontact),
837            "billie" => Ok(Billie),
838            "blik" => Ok(Blik),
839            "boleto" => Ok(Boleto),
840            "card" => Ok(Card),
841            "cashapp" => Ok(Cashapp),
842            "eps" => Ok(Eps),
843            "fpx" => Ok(Fpx),
844            "giropay" => Ok(Giropay),
845            "grabpay" => Ok(Grabpay),
846            "ideal" => Ok(Ideal),
847            "klarna" => Ok(Klarna),
848            "konbini" => Ok(Konbini),
849            "link" => Ok(Link),
850            "mb_way" => Ok(MbWay),
851            "mobilepay" => Ok(Mobilepay),
852            "multibanco" => Ok(Multibanco),
853            "oxxo" => Ok(Oxxo),
854            "p24" => Ok(P24),
855            "pay_by_bank" => Ok(PayByBank),
856            "paynow" => Ok(Paynow),
857            "paypal" => Ok(Paypal),
858            "pix" => Ok(Pix),
859            "promptpay" => Ok(Promptpay),
860            "satispay" => Ok(Satispay),
861            "sepa_debit" => Ok(SepaDebit),
862            "sofort" => Ok(Sofort),
863            "swish" => Ok(Swish),
864            "twint" => Ok(Twint),
865            "us_bank_account" => Ok(UsBankAccount),
866            "wechat_pay" => Ok(WechatPay),
867            "zip" => Ok(Zip),
868            v => {
869                tracing::warn!(
870                    "Unknown value '{}' for enum '{}'",
871                    v,
872                    "PaymentLinkPaymentMethodTypes"
873                );
874                Ok(Unknown(v.to_owned()))
875            }
876        }
877    }
878}
879impl std::fmt::Display for PaymentLinkPaymentMethodTypes {
880    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
881        f.write_str(self.as_str())
882    }
883}
884
885impl std::fmt::Debug for PaymentLinkPaymentMethodTypes {
886    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
887        f.write_str(self.as_str())
888    }
889}
890impl serde::Serialize for PaymentLinkPaymentMethodTypes {
891    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
892    where
893        S: serde::Serializer,
894    {
895        serializer.serialize_str(self.as_str())
896    }
897}
898impl miniserde::Deserialize for PaymentLinkPaymentMethodTypes {
899    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
900        crate::Place::new(out)
901    }
902}
903
904impl miniserde::de::Visitor for crate::Place<PaymentLinkPaymentMethodTypes> {
905    fn string(&mut self, s: &str) -> miniserde::Result<()> {
906        use std::str::FromStr;
907        self.out = Some(PaymentLinkPaymentMethodTypes::from_str(s).expect("infallible"));
908        Ok(())
909    }
910}
911
912stripe_types::impl_from_val_with_from_str!(PaymentLinkPaymentMethodTypes);
913#[cfg(feature = "deserialize")]
914impl<'de> serde::Deserialize<'de> for PaymentLinkPaymentMethodTypes {
915    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
916        use std::str::FromStr;
917        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
918        Ok(Self::from_str(&s).expect("infallible"))
919    }
920}
921#[derive(Clone, Eq, PartialEq)]
922#[non_exhaustive]
923pub enum PaymentLinkSubmitType {
924    Auto,
925    Book,
926    Donate,
927    Pay,
928    Subscribe,
929    /// An unrecognized value from Stripe. Should not be used as a request parameter.
930    Unknown(String),
931}
932impl PaymentLinkSubmitType {
933    pub fn as_str(&self) -> &str {
934        use PaymentLinkSubmitType::*;
935        match self {
936            Auto => "auto",
937            Book => "book",
938            Donate => "donate",
939            Pay => "pay",
940            Subscribe => "subscribe",
941            Unknown(v) => v,
942        }
943    }
944}
945
946impl std::str::FromStr for PaymentLinkSubmitType {
947    type Err = std::convert::Infallible;
948    fn from_str(s: &str) -> Result<Self, Self::Err> {
949        use PaymentLinkSubmitType::*;
950        match s {
951            "auto" => Ok(Auto),
952            "book" => Ok(Book),
953            "donate" => Ok(Donate),
954            "pay" => Ok(Pay),
955            "subscribe" => Ok(Subscribe),
956            v => {
957                tracing::warn!("Unknown value '{}' for enum '{}'", v, "PaymentLinkSubmitType");
958                Ok(Unknown(v.to_owned()))
959            }
960        }
961    }
962}
963impl std::fmt::Display for PaymentLinkSubmitType {
964    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
965        f.write_str(self.as_str())
966    }
967}
968
969impl std::fmt::Debug for PaymentLinkSubmitType {
970    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
971        f.write_str(self.as_str())
972    }
973}
974impl serde::Serialize for PaymentLinkSubmitType {
975    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
976    where
977        S: serde::Serializer,
978    {
979        serializer.serialize_str(self.as_str())
980    }
981}
982impl miniserde::Deserialize for PaymentLinkSubmitType {
983    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
984        crate::Place::new(out)
985    }
986}
987
988impl miniserde::de::Visitor for crate::Place<PaymentLinkSubmitType> {
989    fn string(&mut self, s: &str) -> miniserde::Result<()> {
990        use std::str::FromStr;
991        self.out = Some(PaymentLinkSubmitType::from_str(s).expect("infallible"));
992        Ok(())
993    }
994}
995
996stripe_types::impl_from_val_with_from_str!(PaymentLinkSubmitType);
997#[cfg(feature = "deserialize")]
998impl<'de> serde::Deserialize<'de> for PaymentLinkSubmitType {
999    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1000        use std::str::FromStr;
1001        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
1002        Ok(Self::from_str(&s).expect("infallible"))
1003    }
1004}
stripe_shared/payment_link.rs

stripe_shared/
payment_link.rs
