use serde::{Deserialize, Serialize};
use crate::client::{Client, Response};
use crate::ids::{
CheckoutSessionId, CustomerId, PaymentIntentId, PaymentLinkId, PaymentMethodConfigurationId,
SubscriptionId,
};
use crate::params::{
CurrencyMap, Expand, Expandable, List, Metadata, Object, Paginable, RangeQuery, Timestamp,
};
use crate::resources::{
Address, CheckoutSessionItem, ConnectAccountReference, Currency, Customer, Discount, Invoice,
InvoiceSettingRenderingOptions, LinkedAccountOptionsUsBankAccount, PaymentIntent, PaymentLink,
PaymentMethodConfigBizPaymentMethodConfigurationDetails,
PaymentMethodOptionsCustomerBalanceEuBankAccount, SetupIntent, Shipping, ShippingRate,
Subscription, TaxId, TaxRate,
};
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CheckoutSession {
pub id: CheckoutSessionId,
pub after_expiration: Option<PaymentPagesCheckoutSessionAfterExpiration>,
pub allow_promotion_codes: Option<bool>,
pub amount_subtotal: Option<i64>,
pub amount_total: Option<i64>,
pub automatic_tax: PaymentPagesCheckoutSessionAutomaticTax,
pub billing_address_collection: Option<CheckoutSessionBillingAddressCollection>,
pub cancel_url: Option<String>,
pub client_reference_id: Option<String>,
pub client_secret: Option<String>,
pub consent: Option<PaymentPagesCheckoutSessionConsent>,
pub consent_collection: Option<PaymentPagesCheckoutSessionConsentCollection>,
pub created: Timestamp,
pub currency: Option<Currency>,
pub currency_conversion: Option<PaymentPagesCheckoutSessionCurrencyConversion>,
pub custom_fields: Vec<PaymentPagesCheckoutSessionCustomFields>,
pub custom_text: PaymentPagesCheckoutSessionCustomText,
pub customer: Option<Expandable<Customer>>,
pub customer_creation: Option<CheckoutSessionCustomerCreation>,
pub customer_details: Option<PaymentPagesCheckoutSessionCustomerDetails>,
pub customer_email: Option<String>,
pub expires_at: Timestamp,
pub invoice: Option<Expandable<Invoice>>,
pub invoice_creation: Option<PaymentPagesCheckoutSessionInvoiceCreation>,
#[serde(skip_serializing_if = "Option::is_none")]
pub line_items: Option<List<CheckoutSessionItem>>,
pub livemode: bool,
pub locale: Option<CheckoutSessionLocale>,
pub metadata: Option<Metadata>,
pub mode: CheckoutSessionMode,
pub payment_intent: Option<Expandable<PaymentIntent>>,
pub payment_link: Option<Expandable<PaymentLink>>,
pub payment_method_collection: Option<CheckoutSessionPaymentMethodCollection>,
pub payment_method_configuration_details:
Option<PaymentMethodConfigBizPaymentMethodConfigurationDetails>,
pub payment_method_options: Option<CheckoutSessionPaymentMethodOptions>,
pub payment_method_types: Vec<String>,
pub payment_status: CheckoutSessionPaymentStatus,
#[serde(skip_serializing_if = "Option::is_none")]
pub phone_number_collection: Option<PaymentPagesCheckoutSessionPhoneNumberCollection>,
pub recovered_from: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub redirect_on_completion: Option<CheckoutSessionRedirectOnCompletion>,
#[serde(skip_serializing_if = "Option::is_none")]
pub return_url: Option<String>,
pub setup_intent: Option<Expandable<SetupIntent>>,
pub shipping_address_collection: Option<PaymentPagesCheckoutSessionShippingAddressCollection>,
pub shipping_cost: Option<PaymentPagesCheckoutSessionShippingCost>,
pub shipping_details: Option<Shipping>,
pub shipping_options: Vec<PaymentPagesCheckoutSessionShippingOption>,
pub status: Option<CheckoutSessionStatus>,
pub submit_type: Option<CheckoutSessionSubmitType>,
pub subscription: Option<Expandable<Subscription>>,
pub success_url: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tax_id_collection: Option<PaymentPagesCheckoutSessionTaxIdCollection>,
pub total_details: Option<PaymentPagesCheckoutSessionTotalDetails>,
pub ui_mode: Option<CheckoutSessionUiMode>,
pub url: Option<String>,
}
impl CheckoutSession {
pub fn list(
client: &Client,
params: &ListCheckoutSessions<'_>,
) -> Response<List<CheckoutSession>> {
client.get_query("/checkout/sessions", params)
}
pub fn create(client: &Client, params: CreateCheckoutSession<'_>) -> Response<CheckoutSession> {
#[allow(clippy::needless_borrows_for_generic_args)]
client.post_form("/checkout/sessions", ¶ms)
}
}
impl Object for CheckoutSession {
type Id = CheckoutSessionId;
fn id(&self) -> Self::Id {
self.id.clone()
}
fn object(&self) -> &'static str {
"checkout.session"
}
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CheckoutSessionPaymentMethodOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub acss_debit: Option<CheckoutAcssDebitPaymentMethodOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub affirm: Option<CheckoutAffirmPaymentMethodOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub afterpay_clearpay: Option<CheckoutAfterpayClearpayPaymentMethodOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub alipay: Option<CheckoutAlipayPaymentMethodOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub au_becs_debit: Option<CheckoutAuBecsDebitPaymentMethodOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub bacs_debit: Option<CheckoutBacsDebitPaymentMethodOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub bancontact: Option<CheckoutBancontactPaymentMethodOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub boleto: Option<CheckoutBoletoPaymentMethodOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub card: Option<CheckoutCardPaymentMethodOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub cashapp: Option<CheckoutCashappPaymentMethodOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_balance: Option<CheckoutCustomerBalancePaymentMethodOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub eps: Option<CheckoutEpsPaymentMethodOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub fpx: Option<CheckoutFpxPaymentMethodOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub giropay: Option<CheckoutGiropayPaymentMethodOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub grabpay: Option<CheckoutGrabPayPaymentMethodOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub ideal: Option<CheckoutIdealPaymentMethodOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub klarna: Option<CheckoutKlarnaPaymentMethodOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub konbini: Option<CheckoutKonbiniPaymentMethodOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub link: Option<CheckoutLinkPaymentMethodOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub oxxo: Option<CheckoutOxxoPaymentMethodOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub p24: Option<CheckoutP24PaymentMethodOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub paynow: Option<CheckoutPaynowPaymentMethodOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub paypal: Option<CheckoutPaypalPaymentMethodOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub pix: Option<CheckoutPixPaymentMethodOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub revolut_pay: Option<CheckoutRevolutPayPaymentMethodOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub sepa_debit: Option<CheckoutSepaDebitPaymentMethodOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub sofort: Option<CheckoutSofortPaymentMethodOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub swish: Option<CheckoutSwishPaymentMethodOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub us_bank_account: Option<CheckoutUsBankAccountPaymentMethodOptions>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CheckoutAcssDebitPaymentMethodOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub currency: Option<Currency>,
#[serde(skip_serializing_if = "Option::is_none")]
pub mandate_options: Option<CheckoutAcssDebitMandateOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CheckoutAcssDebitPaymentMethodOptionsSetupFutureUsage>,
#[serde(skip_serializing_if = "Option::is_none")]
pub verification_method: Option<CheckoutAcssDebitPaymentMethodOptionsVerificationMethod>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CheckoutAcssDebitMandateOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_mandate_url: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub default_for: Option<Vec<CheckoutAcssDebitMandateOptionsDefaultFor>>,
pub interval_description: Option<String>,
pub payment_schedule: Option<CheckoutAcssDebitMandateOptionsPaymentSchedule>,
pub transaction_type: Option<CheckoutAcssDebitMandateOptionsTransactionType>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CheckoutAffirmPaymentMethodOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CheckoutAffirmPaymentMethodOptionsSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CheckoutAfterpayClearpayPaymentMethodOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CheckoutAfterpayClearpayPaymentMethodOptionsSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CheckoutAlipayPaymentMethodOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CheckoutAlipayPaymentMethodOptionsSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CheckoutAuBecsDebitPaymentMethodOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CheckoutAuBecsDebitPaymentMethodOptionsSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CheckoutBacsDebitPaymentMethodOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CheckoutBacsDebitPaymentMethodOptionsSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CheckoutBancontactPaymentMethodOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CheckoutBancontactPaymentMethodOptionsSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CheckoutBoletoPaymentMethodOptions {
pub expires_after_days: u32,
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CheckoutBoletoPaymentMethodOptionsSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CheckoutCardPaymentMethodOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub installments: Option<CheckoutCardInstallmentsOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CheckoutCardPaymentMethodOptionsSetupFutureUsage>,
#[serde(skip_serializing_if = "Option::is_none")]
pub statement_descriptor_suffix_kana: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub statement_descriptor_suffix_kanji: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CheckoutCardInstallmentsOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CheckoutCashappPaymentMethodOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CheckoutCashappPaymentMethodOptionsSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CheckoutCustomerBalancePaymentMethodOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub bank_transfer: Option<CheckoutCustomerBalanceBankTransferPaymentMethodOptions>,
pub funding_type: Option<CheckoutCustomerBalancePaymentMethodOptionsFundingType>,
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CheckoutCustomerBalancePaymentMethodOptionsSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CheckoutCustomerBalanceBankTransferPaymentMethodOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub eu_bank_transfer: Option<PaymentMethodOptionsCustomerBalanceEuBankAccount>,
#[serde(skip_serializing_if = "Option::is_none")]
pub requested_address_types:
Option<Vec<CheckoutCustomerBalanceBankTransferPaymentMethodOptionsRequestedAddressTypes>>,
#[serde(rename = "type")]
pub type_: Option<CheckoutCustomerBalanceBankTransferPaymentMethodOptionsType>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CheckoutEpsPaymentMethodOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CheckoutEpsPaymentMethodOptionsSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CheckoutFpxPaymentMethodOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CheckoutFpxPaymentMethodOptionsSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CheckoutGiropayPaymentMethodOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CheckoutGiropayPaymentMethodOptionsSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CheckoutGrabPayPaymentMethodOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CheckoutGrabPayPaymentMethodOptionsSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CheckoutIdealPaymentMethodOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CheckoutIdealPaymentMethodOptionsSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CheckoutKlarnaPaymentMethodOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CheckoutKlarnaPaymentMethodOptionsSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CheckoutKonbiniPaymentMethodOptions {
pub expires_after_days: Option<u32>,
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CheckoutKonbiniPaymentMethodOptionsSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CheckoutLinkPaymentMethodOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CheckoutLinkPaymentMethodOptionsSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CheckoutOxxoPaymentMethodOptions {
pub expires_after_days: u32,
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CheckoutOxxoPaymentMethodOptionsSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CheckoutP24PaymentMethodOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CheckoutP24PaymentMethodOptionsSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CheckoutPaynowPaymentMethodOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CheckoutPaynowPaymentMethodOptionsSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CheckoutPaypalPaymentMethodOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub capture_method: Option<CheckoutPaypalPaymentMethodOptionsCaptureMethod>,
pub preferred_locale: Option<String>,
pub reference: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CheckoutPaypalPaymentMethodOptionsSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CheckoutPixPaymentMethodOptions {
pub expires_after_seconds: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CheckoutRevolutPayPaymentMethodOptions {}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CheckoutSepaDebitPaymentMethodOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CheckoutSepaDebitPaymentMethodOptionsSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CheckoutSofortPaymentMethodOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CheckoutSofortPaymentMethodOptionsSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CheckoutSwishPaymentMethodOptions {
pub reference: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CheckoutUsBankAccountPaymentMethodOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub financial_connections: Option<LinkedAccountOptionsUsBankAccount>,
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CheckoutUsBankAccountPaymentMethodOptionsSetupFutureUsage>,
#[serde(skip_serializing_if = "Option::is_none")]
pub verification_method: Option<CheckoutUsBankAccountPaymentMethodOptionsVerificationMethod>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentPagesCheckoutSessionAfterExpiration {
pub recovery: Option<PaymentPagesCheckoutSessionAfterExpirationRecovery>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentPagesCheckoutSessionAfterExpirationRecovery {
pub allow_promotion_codes: bool,
pub enabled: bool,
pub expires_at: Option<Timestamp>,
pub url: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentPagesCheckoutSessionAutomaticTax {
pub enabled: bool,
pub liability: Option<ConnectAccountReference>,
pub status: Option<PaymentPagesCheckoutSessionAutomaticTaxStatus>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentPagesCheckoutSessionConsent {
pub promotions: Option<PaymentPagesCheckoutSessionConsentPromotions>,
pub terms_of_service: Option<PaymentPagesCheckoutSessionConsentTermsOfService>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentPagesCheckoutSessionConsentCollection {
pub payment_method_reuse_agreement:
Option<PaymentPagesCheckoutSessionPaymentMethodReuseAgreement>,
pub promotions: Option<PaymentPagesCheckoutSessionConsentCollectionPromotions>,
pub terms_of_service: Option<PaymentPagesCheckoutSessionConsentCollectionTermsOfService>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentPagesCheckoutSessionCurrencyConversion {
pub amount_subtotal: i64,
pub amount_total: i64,
pub fx_rate: String,
pub source_currency: Currency,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentPagesCheckoutSessionCustomFields {
#[serde(skip_serializing_if = "Option::is_none")]
pub dropdown: Option<PaymentPagesCheckoutSessionCustomFieldsDropdown>,
pub key: String,
pub label: PaymentPagesCheckoutSessionCustomFieldsLabel,
#[serde(skip_serializing_if = "Option::is_none")]
pub numeric: Option<PaymentPagesCheckoutSessionCustomFieldsNumeric>,
pub optional: bool,
#[serde(skip_serializing_if = "Option::is_none")]
pub text: Option<PaymentPagesCheckoutSessionCustomFieldsText>,
#[serde(rename = "type")]
pub type_: PaymentPagesCheckoutSessionCustomFieldsType,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentPagesCheckoutSessionCustomFieldsDropdown {
pub options: Vec<PaymentPagesCheckoutSessionCustomFieldsOption>,
pub value: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentPagesCheckoutSessionCustomFieldsLabel {
pub custom: Option<String>,
#[serde(rename = "type")]
pub type_: PaymentPagesCheckoutSessionCustomFieldsLabelType,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentPagesCheckoutSessionCustomFieldsNumeric {
pub maximum_length: Option<i64>,
pub minimum_length: Option<i64>,
pub value: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentPagesCheckoutSessionCustomFieldsOption {
pub label: String,
pub value: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentPagesCheckoutSessionCustomFieldsText {
pub maximum_length: Option<i64>,
pub minimum_length: Option<i64>,
pub value: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentPagesCheckoutSessionCustomText {
pub after_submit: Option<PaymentPagesCheckoutSessionCustomTextPosition>,
pub shipping_address: Option<PaymentPagesCheckoutSessionCustomTextPosition>,
pub submit: Option<PaymentPagesCheckoutSessionCustomTextPosition>,
pub terms_of_service_acceptance: Option<PaymentPagesCheckoutSessionCustomTextPosition>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentPagesCheckoutSessionCustomTextPosition {
pub message: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentPagesCheckoutSessionCustomerDetails {
pub address: Option<Address>,
pub email: Option<String>,
pub name: Option<String>,
pub phone: Option<String>,
pub tax_exempt: Option<PaymentPagesCheckoutSessionCustomerDetailsTaxExempt>,
pub tax_ids: Option<Vec<PaymentPagesCheckoutSessionTaxId>>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentPagesCheckoutSessionInvoiceCreation {
pub enabled: bool,
pub invoice_data: PaymentPagesCheckoutSessionInvoiceSettings,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentPagesCheckoutSessionInvoiceSettings {
pub account_tax_ids: Option<Vec<Expandable<TaxId>>>,
pub custom_fields: Option<Vec<InvoiceSettingCustomField>>,
pub description: Option<String>,
pub footer: Option<String>,
pub issuer: Option<ConnectAccountReference>,
pub metadata: Option<Metadata>,
pub rendering_options: Option<InvoiceSettingRenderingOptions>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct InvoiceSettingCustomField {
pub name: String,
pub value: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentPagesCheckoutSessionPaymentMethodReuseAgreement {
pub position: PaymentPagesCheckoutSessionPaymentMethodReuseAgreementPosition,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentPagesCheckoutSessionPhoneNumberCollection {
pub enabled: bool,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentPagesCheckoutSessionShippingAddressCollection {
pub allowed_countries:
Vec<PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentPagesCheckoutSessionShippingCost {
pub amount_subtotal: i64,
pub amount_tax: i64,
pub amount_total: i64,
pub shipping_rate: Option<Expandable<ShippingRate>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub taxes: Option<Vec<LineItemsTaxAmount>>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct LineItemsTaxAmount {
pub amount: i64,
pub rate: TaxRate,
pub taxability_reason: Option<LineItemsTaxAmountTaxabilityReason>,
pub taxable_amount: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentPagesCheckoutSessionShippingOption {
pub shipping_amount: i64,
pub shipping_rate: Expandable<ShippingRate>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentPagesCheckoutSessionTaxId {
#[serde(rename = "type")]
pub type_: PaymentPagesCheckoutSessionTaxIdType,
pub value: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentPagesCheckoutSessionTaxIdCollection {
pub enabled: bool,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentPagesCheckoutSessionTotalDetails {
pub amount_discount: i64,
pub amount_shipping: Option<i64>,
pub amount_tax: i64,
#[serde(skip_serializing_if = "Option::is_none")]
pub breakdown: Option<PaymentPagesCheckoutSessionTotalDetailsResourceBreakdown>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentPagesCheckoutSessionTotalDetailsResourceBreakdown {
pub discounts: Vec<LineItemsDiscountAmount>,
pub taxes: Vec<LineItemsTaxAmount>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct LineItemsDiscountAmount {
pub amount: i64,
pub discount: Discount,
}
#[derive(Clone, Debug, Serialize, Default)]
pub struct CreateCheckoutSession<'a> {
#[serde(skip_serializing_if = "Option::is_none")]
pub after_expiration: Option<CreateCheckoutSessionAfterExpiration>,
#[serde(skip_serializing_if = "Option::is_none")]
pub allow_promotion_codes: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub automatic_tax: Option<CreateCheckoutSessionAutomaticTax>,
#[serde(skip_serializing_if = "Option::is_none")]
pub billing_address_collection: Option<CheckoutSessionBillingAddressCollection>,
#[serde(skip_serializing_if = "Option::is_none")]
pub cancel_url: Option<&'a str>,
#[serde(skip_serializing_if = "Option::is_none")]
pub client_reference_id: Option<&'a str>,
#[serde(skip_serializing_if = "Option::is_none")]
pub consent_collection: Option<CreateCheckoutSessionConsentCollection>,
#[serde(skip_serializing_if = "Option::is_none")]
pub currency: Option<Currency>,
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_fields: Option<Vec<CreateCheckoutSessionCustomFields>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_text: Option<CreateCheckoutSessionCustomText>,
#[serde(skip_serializing_if = "Option::is_none")]
pub customer: Option<CustomerId>,
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_creation: Option<CheckoutSessionCustomerCreation>,
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_email: Option<&'a str>,
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_update: Option<CreateCheckoutSessionCustomerUpdate>,
#[serde(skip_serializing_if = "Option::is_none")]
pub discounts: Option<Vec<CreateCheckoutSessionDiscounts>>,
#[serde(skip_serializing_if = "Expand::is_empty")]
pub expand: &'a [&'a str],
#[serde(skip_serializing_if = "Option::is_none")]
pub expires_at: Option<Timestamp>,
#[serde(skip_serializing_if = "Option::is_none")]
pub invoice_creation: Option<CreateCheckoutSessionInvoiceCreation>,
#[serde(skip_serializing_if = "Option::is_none")]
pub line_items: Option<Vec<CreateCheckoutSessionLineItems>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub locale: Option<CheckoutSessionLocale>,
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata: Option<Metadata>,
#[serde(skip_serializing_if = "Option::is_none")]
pub mode: Option<CheckoutSessionMode>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_intent_data: Option<CreateCheckoutSessionPaymentIntentData>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method_collection: Option<CheckoutSessionPaymentMethodCollection>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method_configuration: Option<PaymentMethodConfigurationId>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method_options: Option<CreateCheckoutSessionPaymentMethodOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method_types: Option<Vec<CreateCheckoutSessionPaymentMethodTypes>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub phone_number_collection: Option<CreateCheckoutSessionPhoneNumberCollection>,
#[serde(skip_serializing_if = "Option::is_none")]
pub redirect_on_completion: Option<CheckoutSessionRedirectOnCompletion>,
#[serde(skip_serializing_if = "Option::is_none")]
pub return_url: Option<&'a str>,
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_intent_data: Option<CreateCheckoutSessionSetupIntentData>,
#[serde(skip_serializing_if = "Option::is_none")]
pub shipping_address_collection: Option<CreateCheckoutSessionShippingAddressCollection>,
#[serde(skip_serializing_if = "Option::is_none")]
pub shipping_options: Option<Vec<CreateCheckoutSessionShippingOptions>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub submit_type: Option<CheckoutSessionSubmitType>,
#[serde(skip_serializing_if = "Option::is_none")]
pub subscription_data: Option<CreateCheckoutSessionSubscriptionData>,
#[serde(skip_serializing_if = "Option::is_none")]
pub success_url: Option<&'a str>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tax_id_collection: Option<CreateCheckoutSessionTaxIdCollection>,
#[serde(skip_serializing_if = "Option::is_none")]
pub ui_mode: Option<CheckoutSessionUiMode>,
}
impl<'a> CreateCheckoutSession<'a> {
pub fn new() -> Self {
CreateCheckoutSession {
after_expiration: Default::default(),
allow_promotion_codes: Default::default(),
automatic_tax: Default::default(),
billing_address_collection: Default::default(),
cancel_url: Default::default(),
client_reference_id: Default::default(),
consent_collection: Default::default(),
currency: Default::default(),
custom_fields: Default::default(),
custom_text: Default::default(),
customer: Default::default(),
customer_creation: Default::default(),
customer_email: Default::default(),
customer_update: Default::default(),
discounts: Default::default(),
expand: Default::default(),
expires_at: Default::default(),
invoice_creation: Default::default(),
line_items: Default::default(),
locale: Default::default(),
metadata: Default::default(),
mode: Default::default(),
payment_intent_data: Default::default(),
payment_method_collection: Default::default(),
payment_method_configuration: Default::default(),
payment_method_options: Default::default(),
payment_method_types: Default::default(),
phone_number_collection: Default::default(),
redirect_on_completion: Default::default(),
return_url: Default::default(),
setup_intent_data: Default::default(),
shipping_address_collection: Default::default(),
shipping_options: Default::default(),
submit_type: Default::default(),
subscription_data: Default::default(),
success_url: Default::default(),
tax_id_collection: Default::default(),
ui_mode: Default::default(),
}
}
}
#[derive(Clone, Debug, Serialize, Default)]
pub struct ListCheckoutSessions<'a> {
#[serde(skip_serializing_if = "Option::is_none")]
pub created: Option<RangeQuery<Timestamp>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub customer: Option<CustomerId>,
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_details: Option<ListCheckoutSessionsCustomerDetails>,
#[serde(skip_serializing_if = "Option::is_none")]
pub ending_before: Option<CheckoutSessionId>,
#[serde(skip_serializing_if = "Expand::is_empty")]
pub expand: &'a [&'a str],
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<u64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_intent: Option<PaymentIntentId>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_link: Option<PaymentLinkId>,
#[serde(skip_serializing_if = "Option::is_none")]
pub starting_after: Option<CheckoutSessionId>,
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<CheckoutSessionStatus>,
#[serde(skip_serializing_if = "Option::is_none")]
pub subscription: Option<SubscriptionId>,
}
impl<'a> ListCheckoutSessions<'a> {
pub fn new() -> Self {
ListCheckoutSessions {
created: Default::default(),
customer: Default::default(),
customer_details: Default::default(),
ending_before: Default::default(),
expand: Default::default(),
limit: Default::default(),
payment_intent: Default::default(),
payment_link: Default::default(),
starting_after: Default::default(),
status: Default::default(),
subscription: Default::default(),
}
}
}
impl Paginable for ListCheckoutSessions<'_> {
type O = CheckoutSession;
fn set_last(&mut self, item: Self::O) {
self.starting_after = Some(item.id());
}
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionAfterExpiration {
#[serde(skip_serializing_if = "Option::is_none")]
pub recovery: Option<CreateCheckoutSessionAfterExpirationRecovery>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionAutomaticTax {
pub enabled: bool,
#[serde(skip_serializing_if = "Option::is_none")]
pub liability: Option<CreateCheckoutSessionAutomaticTaxLiability>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionConsentCollection {
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method_reuse_agreement:
Option<CreateCheckoutSessionConsentCollectionPaymentMethodReuseAgreement>,
#[serde(skip_serializing_if = "Option::is_none")]
pub promotions: Option<CreateCheckoutSessionConsentCollectionPromotions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub terms_of_service: Option<CreateCheckoutSessionConsentCollectionTermsOfService>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionCustomFields {
#[serde(skip_serializing_if = "Option::is_none")]
pub dropdown: Option<CreateCheckoutSessionCustomFieldsDropdown>,
pub key: String,
pub label: CreateCheckoutSessionCustomFieldsLabel,
#[serde(skip_serializing_if = "Option::is_none")]
pub numeric: Option<CreateCheckoutSessionCustomFieldsNumeric>,
#[serde(skip_serializing_if = "Option::is_none")]
pub optional: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub text: Option<CreateCheckoutSessionCustomFieldsText>,
#[serde(rename = "type")]
pub type_: CreateCheckoutSessionCustomFieldsType,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionCustomText {
#[serde(skip_serializing_if = "Option::is_none")]
pub after_submit: Option<CreateCheckoutSessionCustomTextAfterSubmit>,
#[serde(skip_serializing_if = "Option::is_none")]
pub shipping_address: Option<CreateCheckoutSessionCustomTextShippingAddress>,
#[serde(skip_serializing_if = "Option::is_none")]
pub submit: Option<CreateCheckoutSessionCustomTextSubmit>,
#[serde(skip_serializing_if = "Option::is_none")]
pub terms_of_service_acceptance:
Option<CreateCheckoutSessionCustomTextTermsOfServiceAcceptance>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionCustomerUpdate {
#[serde(skip_serializing_if = "Option::is_none")]
pub address: Option<CreateCheckoutSessionCustomerUpdateAddress>,
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<CreateCheckoutSessionCustomerUpdateName>,
#[serde(skip_serializing_if = "Option::is_none")]
pub shipping: Option<CreateCheckoutSessionCustomerUpdateShipping>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionDiscounts {
#[serde(skip_serializing_if = "Option::is_none")]
pub coupon: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub promotion_code: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionInvoiceCreation {
pub enabled: bool,
#[serde(skip_serializing_if = "Option::is_none")]
pub invoice_data: Option<CreateCheckoutSessionInvoiceCreationInvoiceData>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionLineItems {
#[serde(skip_serializing_if = "Option::is_none")]
pub adjustable_quantity: Option<CreateCheckoutSessionLineItemsAdjustableQuantity>,
#[serde(skip_serializing_if = "Option::is_none")]
pub dynamic_tax_rates: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub price: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub price_data: Option<CreateCheckoutSessionLineItemsPriceData>,
#[serde(skip_serializing_if = "Option::is_none")]
pub quantity: Option<u64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tax_rates: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentIntentData {
#[serde(skip_serializing_if = "Option::is_none")]
pub application_fee_amount: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub capture_method: Option<CreateCheckoutSessionPaymentIntentDataCaptureMethod>,
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata: Option<Metadata>,
#[serde(skip_serializing_if = "Option::is_none")]
pub on_behalf_of: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub receipt_email: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CreateCheckoutSessionPaymentIntentDataSetupFutureUsage>,
#[serde(skip_serializing_if = "Option::is_none")]
pub shipping: Option<CreateCheckoutSessionPaymentIntentDataShipping>,
#[serde(skip_serializing_if = "Option::is_none")]
pub statement_descriptor: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub statement_descriptor_suffix: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub transfer_data: Option<CreateCheckoutSessionPaymentIntentDataTransferData>,
#[serde(skip_serializing_if = "Option::is_none")]
pub transfer_group: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub acss_debit: Option<CreateCheckoutSessionPaymentMethodOptionsAcssDebit>,
#[serde(skip_serializing_if = "Option::is_none")]
pub affirm: Option<CreateCheckoutSessionPaymentMethodOptionsAffirm>,
#[serde(skip_serializing_if = "Option::is_none")]
pub afterpay_clearpay: Option<CreateCheckoutSessionPaymentMethodOptionsAfterpayClearpay>,
#[serde(skip_serializing_if = "Option::is_none")]
pub alipay: Option<CreateCheckoutSessionPaymentMethodOptionsAlipay>,
#[serde(skip_serializing_if = "Option::is_none")]
pub au_becs_debit: Option<CreateCheckoutSessionPaymentMethodOptionsAuBecsDebit>,
#[serde(skip_serializing_if = "Option::is_none")]
pub bacs_debit: Option<CreateCheckoutSessionPaymentMethodOptionsBacsDebit>,
#[serde(skip_serializing_if = "Option::is_none")]
pub bancontact: Option<CreateCheckoutSessionPaymentMethodOptionsBancontact>,
#[serde(skip_serializing_if = "Option::is_none")]
pub boleto: Option<CreateCheckoutSessionPaymentMethodOptionsBoleto>,
#[serde(skip_serializing_if = "Option::is_none")]
pub card: Option<CreateCheckoutSessionPaymentMethodOptionsCard>,
#[serde(skip_serializing_if = "Option::is_none")]
pub cashapp: Option<CreateCheckoutSessionPaymentMethodOptionsCashapp>,
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_balance: Option<CreateCheckoutSessionPaymentMethodOptionsCustomerBalance>,
#[serde(skip_serializing_if = "Option::is_none")]
pub eps: Option<CreateCheckoutSessionPaymentMethodOptionsEps>,
#[serde(skip_serializing_if = "Option::is_none")]
pub fpx: Option<CreateCheckoutSessionPaymentMethodOptionsFpx>,
#[serde(skip_serializing_if = "Option::is_none")]
pub giropay: Option<CreateCheckoutSessionPaymentMethodOptionsGiropay>,
#[serde(skip_serializing_if = "Option::is_none")]
pub grabpay: Option<CreateCheckoutSessionPaymentMethodOptionsGrabpay>,
#[serde(skip_serializing_if = "Option::is_none")]
pub ideal: Option<CreateCheckoutSessionPaymentMethodOptionsIdeal>,
#[serde(skip_serializing_if = "Option::is_none")]
pub klarna: Option<CreateCheckoutSessionPaymentMethodOptionsKlarna>,
#[serde(skip_serializing_if = "Option::is_none")]
pub konbini: Option<CreateCheckoutSessionPaymentMethodOptionsKonbini>,
#[serde(skip_serializing_if = "Option::is_none")]
pub link: Option<CreateCheckoutSessionPaymentMethodOptionsLink>,
#[serde(skip_serializing_if = "Option::is_none")]
pub oxxo: Option<CreateCheckoutSessionPaymentMethodOptionsOxxo>,
#[serde(skip_serializing_if = "Option::is_none")]
pub p24: Option<CreateCheckoutSessionPaymentMethodOptionsP24>,
#[serde(skip_serializing_if = "Option::is_none")]
pub paynow: Option<CreateCheckoutSessionPaymentMethodOptionsPaynow>,
#[serde(skip_serializing_if = "Option::is_none")]
pub paypal: Option<CreateCheckoutSessionPaymentMethodOptionsPaypal>,
#[serde(skip_serializing_if = "Option::is_none")]
pub pix: Option<CreateCheckoutSessionPaymentMethodOptionsPix>,
#[serde(skip_serializing_if = "Option::is_none")]
pub revolut_pay: Option<CreateCheckoutSessionPaymentMethodOptionsRevolutPay>,
#[serde(skip_serializing_if = "Option::is_none")]
pub sepa_debit: Option<CreateCheckoutSessionPaymentMethodOptionsSepaDebit>,
#[serde(skip_serializing_if = "Option::is_none")]
pub sofort: Option<CreateCheckoutSessionPaymentMethodOptionsSofort>,
#[serde(skip_serializing_if = "Option::is_none")]
pub swish: Option<CreateCheckoutSessionPaymentMethodOptionsSwish>,
#[serde(skip_serializing_if = "Option::is_none")]
pub us_bank_account: Option<CreateCheckoutSessionPaymentMethodOptionsUsBankAccount>,
#[serde(skip_serializing_if = "Option::is_none")]
pub wechat_pay: Option<CreateCheckoutSessionPaymentMethodOptionsWechatPay>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPhoneNumberCollection {
pub enabled: bool,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionSetupIntentData {
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata: Option<Metadata>,
#[serde(skip_serializing_if = "Option::is_none")]
pub on_behalf_of: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionShippingAddressCollection {
pub allowed_countries: Vec<CreateCheckoutSessionShippingAddressCollectionAllowedCountries>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionShippingOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub shipping_rate: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub shipping_rate_data: Option<CreateCheckoutSessionShippingOptionsShippingRateData>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionSubscriptionData {
#[serde(skip_serializing_if = "Option::is_none")]
pub application_fee_percent: Option<f64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub billing_cycle_anchor: Option<Timestamp>,
#[serde(skip_serializing_if = "Option::is_none")]
pub default_tax_rates: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub invoice_settings: Option<CreateCheckoutSessionSubscriptionDataInvoiceSettings>,
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata: Option<Metadata>,
#[serde(skip_serializing_if = "Option::is_none")]
pub on_behalf_of: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub proration_behavior: Option<CreateCheckoutSessionSubscriptionDataProrationBehavior>,
#[serde(skip_serializing_if = "Option::is_none")]
pub transfer_data: Option<CreateCheckoutSessionSubscriptionDataTransferData>,
#[serde(skip_serializing_if = "Option::is_none")]
pub trial_end: Option<Timestamp>,
#[serde(skip_serializing_if = "Option::is_none")]
pub trial_period_days: Option<u32>,
#[serde(skip_serializing_if = "Option::is_none")]
pub trial_settings: Option<CreateCheckoutSessionSubscriptionDataTrialSettings>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionTaxIdCollection {
pub enabled: bool,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct ListCheckoutSessionsCustomerDetails {
pub email: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionAfterExpirationRecovery {
#[serde(skip_serializing_if = "Option::is_none")]
pub allow_promotion_codes: Option<bool>,
pub enabled: bool,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionAutomaticTaxLiability {
#[serde(skip_serializing_if = "Option::is_none")]
pub account: Option<String>,
#[serde(rename = "type")]
pub type_: CreateCheckoutSessionAutomaticTaxLiabilityType,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionConsentCollectionPaymentMethodReuseAgreement {
pub position: CreateCheckoutSessionConsentCollectionPaymentMethodReuseAgreementPosition,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionCustomFieldsDropdown {
pub options: Vec<CreateCheckoutSessionCustomFieldsDropdownOptions>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionCustomFieldsLabel {
pub custom: String,
#[serde(rename = "type")]
pub type_: CreateCheckoutSessionCustomFieldsLabelType,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionCustomFieldsNumeric {
#[serde(skip_serializing_if = "Option::is_none")]
pub maximum_length: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub minimum_length: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionCustomFieldsText {
#[serde(skip_serializing_if = "Option::is_none")]
pub maximum_length: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub minimum_length: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionCustomTextAfterSubmit {
pub message: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionCustomTextShippingAddress {
pub message: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionCustomTextSubmit {
pub message: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionCustomTextTermsOfServiceAcceptance {
pub message: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionInvoiceCreationInvoiceData {
#[serde(skip_serializing_if = "Option::is_none")]
pub account_tax_ids: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_fields: Option<Vec<CreateCheckoutSessionInvoiceCreationInvoiceDataCustomFields>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub footer: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub issuer: Option<CreateCheckoutSessionInvoiceCreationInvoiceDataIssuer>,
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata: Option<Metadata>,
#[serde(skip_serializing_if = "Option::is_none")]
pub rendering_options: Option<CreateCheckoutSessionInvoiceCreationInvoiceDataRenderingOptions>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionLineItemsAdjustableQuantity {
pub enabled: bool,
#[serde(skip_serializing_if = "Option::is_none")]
pub maximum: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub minimum: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionLineItemsPriceData {
pub currency: Currency,
#[serde(skip_serializing_if = "Option::is_none")]
pub product: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub product_data: Option<CreateCheckoutSessionLineItemsPriceDataProductData>,
#[serde(skip_serializing_if = "Option::is_none")]
pub recurring: Option<CreateCheckoutSessionLineItemsPriceDataRecurring>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tax_behavior: Option<CreateCheckoutSessionLineItemsPriceDataTaxBehavior>,
#[serde(skip_serializing_if = "Option::is_none")]
pub unit_amount: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub unit_amount_decimal: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentIntentDataShipping {
pub address: CreateCheckoutSessionPaymentIntentDataShippingAddress,
#[serde(skip_serializing_if = "Option::is_none")]
pub carrier: Option<String>,
pub name: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub phone: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tracking_number: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentIntentDataTransferData {
#[serde(skip_serializing_if = "Option::is_none")]
pub amount: Option<i64>,
pub destination: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsAcssDebit {
#[serde(skip_serializing_if = "Option::is_none")]
pub currency: Option<Currency>,
#[serde(skip_serializing_if = "Option::is_none")]
pub mandate_options: Option<CreateCheckoutSessionPaymentMethodOptionsAcssDebitMandateOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage:
Option<CreateCheckoutSessionPaymentMethodOptionsAcssDebitSetupFutureUsage>,
#[serde(skip_serializing_if = "Option::is_none")]
pub verification_method:
Option<CreateCheckoutSessionPaymentMethodOptionsAcssDebitVerificationMethod>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsAffirm {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CreateCheckoutSessionPaymentMethodOptionsAffirmSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsAfterpayClearpay {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage:
Option<CreateCheckoutSessionPaymentMethodOptionsAfterpayClearpaySetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsAlipay {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CreateCheckoutSessionPaymentMethodOptionsAlipaySetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsAuBecsDebit {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage:
Option<CreateCheckoutSessionPaymentMethodOptionsAuBecsDebitSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsBacsDebit {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage:
Option<CreateCheckoutSessionPaymentMethodOptionsBacsDebitSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsBancontact {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage:
Option<CreateCheckoutSessionPaymentMethodOptionsBancontactSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsBoleto {
#[serde(skip_serializing_if = "Option::is_none")]
pub expires_after_days: Option<u32>,
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CreateCheckoutSessionPaymentMethodOptionsBoletoSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsCard {
#[serde(skip_serializing_if = "Option::is_none")]
pub installments: Option<CreateCheckoutSessionPaymentMethodOptionsCardInstallments>,
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CreateCheckoutSessionPaymentMethodOptionsCardSetupFutureUsage>,
#[serde(skip_serializing_if = "Option::is_none")]
pub statement_descriptor_suffix_kana: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub statement_descriptor_suffix_kanji: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsCashapp {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage:
Option<CreateCheckoutSessionPaymentMethodOptionsCashappSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsCustomerBalance {
#[serde(skip_serializing_if = "Option::is_none")]
pub bank_transfer: Option<CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceBankTransfer>,
#[serde(skip_serializing_if = "Option::is_none")]
pub funding_type: Option<CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceFundingType>,
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage:
Option<CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsEps {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CreateCheckoutSessionPaymentMethodOptionsEpsSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsFpx {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CreateCheckoutSessionPaymentMethodOptionsFpxSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsGiropay {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage:
Option<CreateCheckoutSessionPaymentMethodOptionsGiropaySetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsGrabpay {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage:
Option<CreateCheckoutSessionPaymentMethodOptionsGrabpaySetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsIdeal {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CreateCheckoutSessionPaymentMethodOptionsIdealSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsKlarna {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CreateCheckoutSessionPaymentMethodOptionsKlarnaSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsKonbini {
#[serde(skip_serializing_if = "Option::is_none")]
pub expires_after_days: Option<u32>,
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage:
Option<CreateCheckoutSessionPaymentMethodOptionsKonbiniSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsLink {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CreateCheckoutSessionPaymentMethodOptionsLinkSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsOxxo {
#[serde(skip_serializing_if = "Option::is_none")]
pub expires_after_days: Option<u32>,
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CreateCheckoutSessionPaymentMethodOptionsOxxoSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsP24 {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CreateCheckoutSessionPaymentMethodOptionsP24SetupFutureUsage>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tos_shown_and_accepted: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsPaynow {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CreateCheckoutSessionPaymentMethodOptionsPaynowSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsPaypal {
#[serde(skip_serializing_if = "Option::is_none")]
pub capture_method: Option<CreateCheckoutSessionPaymentMethodOptionsPaypalCaptureMethod>,
#[serde(skip_serializing_if = "Option::is_none")]
pub preferred_locale: Option<CreateCheckoutSessionPaymentMethodOptionsPaypalPreferredLocale>,
#[serde(skip_serializing_if = "Option::is_none")]
pub reference: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub risk_correlation_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CreateCheckoutSessionPaymentMethodOptionsPaypalSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsPix {
#[serde(skip_serializing_if = "Option::is_none")]
pub expires_after_seconds: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsRevolutPay {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage:
Option<CreateCheckoutSessionPaymentMethodOptionsRevolutPaySetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsSepaDebit {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage:
Option<CreateCheckoutSessionPaymentMethodOptionsSepaDebitSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsSofort {
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage: Option<CreateCheckoutSessionPaymentMethodOptionsSofortSetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsSwish {
#[serde(skip_serializing_if = "Option::is_none")]
pub reference: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsUsBankAccount {
#[serde(skip_serializing_if = "Option::is_none")]
pub financial_connections:
Option<CreateCheckoutSessionPaymentMethodOptionsUsBankAccountFinancialConnections>,
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage:
Option<CreateCheckoutSessionPaymentMethodOptionsUsBankAccountSetupFutureUsage>,
#[serde(skip_serializing_if = "Option::is_none")]
pub verification_method:
Option<CreateCheckoutSessionPaymentMethodOptionsUsBankAccountVerificationMethod>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsWechatPay {
#[serde(skip_serializing_if = "Option::is_none")]
pub app_id: Option<String>,
pub client: CreateCheckoutSessionPaymentMethodOptionsWechatPayClient,
#[serde(skip_serializing_if = "Option::is_none")]
pub setup_future_usage:
Option<CreateCheckoutSessionPaymentMethodOptionsWechatPaySetupFutureUsage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionShippingOptionsShippingRateData {
#[serde(skip_serializing_if = "Option::is_none")]
pub delivery_estimate:
Option<CreateCheckoutSessionShippingOptionsShippingRateDataDeliveryEstimate>,
pub display_name: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub fixed_amount: Option<CreateCheckoutSessionShippingOptionsShippingRateDataFixedAmount>,
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata: Option<Metadata>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tax_behavior: Option<CreateCheckoutSessionShippingOptionsShippingRateDataTaxBehavior>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tax_code: Option<String>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<CreateCheckoutSessionShippingOptionsShippingRateDataType>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionSubscriptionDataInvoiceSettings {
#[serde(skip_serializing_if = "Option::is_none")]
pub issuer: Option<CreateCheckoutSessionSubscriptionDataInvoiceSettingsIssuer>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionSubscriptionDataTransferData {
#[serde(skip_serializing_if = "Option::is_none")]
pub amount_percent: Option<f64>,
pub destination: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionSubscriptionDataTrialSettings {
pub end_behavior: CreateCheckoutSessionSubscriptionDataTrialSettingsEndBehavior,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionCustomFieldsDropdownOptions {
pub label: String,
pub value: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionInvoiceCreationInvoiceDataCustomFields {
pub name: String,
pub value: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionInvoiceCreationInvoiceDataIssuer {
#[serde(skip_serializing_if = "Option::is_none")]
pub account: Option<String>,
#[serde(rename = "type")]
pub type_: CreateCheckoutSessionInvoiceCreationInvoiceDataIssuerType,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionInvoiceCreationInvoiceDataRenderingOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub amount_tax_display:
Option<CreateCheckoutSessionInvoiceCreationInvoiceDataRenderingOptionsAmountTaxDisplay>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionLineItemsPriceDataProductData {
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub images: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata: Option<Metadata>,
pub name: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub tax_code: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionLineItemsPriceDataRecurring {
pub interval: CreateCheckoutSessionLineItemsPriceDataRecurringInterval,
#[serde(skip_serializing_if = "Option::is_none")]
pub interval_count: Option<u64>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentIntentDataShippingAddress {
#[serde(skip_serializing_if = "Option::is_none")]
pub city: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub country: Option<String>,
pub line1: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub line2: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub postal_code: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsAcssDebitMandateOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_mandate_url: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub default_for:
Option<Vec<CreateCheckoutSessionPaymentMethodOptionsAcssDebitMandateOptionsDefaultFor>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub interval_description: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_schedule:
Option<CreateCheckoutSessionPaymentMethodOptionsAcssDebitMandateOptionsPaymentSchedule>,
#[serde(skip_serializing_if = "Option::is_none")]
pub transaction_type:
Option<CreateCheckoutSessionPaymentMethodOptionsAcssDebitMandateOptionsTransactionType>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsCardInstallments {
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceBankTransfer {
#[serde(skip_serializing_if = "Option::is_none")]
pub eu_bank_transfer: Option<CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceBankTransferEuBankTransfer>,
#[serde(skip_serializing_if = "Option::is_none")]
pub requested_address_types: Option<Vec<CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceBankTransferRequestedAddressTypes>>,
#[serde(rename = "type")]
pub type_: CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceBankTransferType,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsUsBankAccountFinancialConnections {
#[serde(skip_serializing_if = "Option::is_none")]
pub permissions: Option<
Vec<CreateCheckoutSessionPaymentMethodOptionsUsBankAccountFinancialConnectionsPermissions>,
>,
#[serde(skip_serializing_if = "Option::is_none")]
pub prefetch: Option<
Vec<CreateCheckoutSessionPaymentMethodOptionsUsBankAccountFinancialConnectionsPrefetch>,
>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionShippingOptionsShippingRateDataDeliveryEstimate {
#[serde(skip_serializing_if = "Option::is_none")]
pub maximum:
Option<CreateCheckoutSessionShippingOptionsShippingRateDataDeliveryEstimateMaximum>,
#[serde(skip_serializing_if = "Option::is_none")]
pub minimum:
Option<CreateCheckoutSessionShippingOptionsShippingRateDataDeliveryEstimateMinimum>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionShippingOptionsShippingRateDataFixedAmount {
pub amount: i64,
pub currency: Currency,
#[serde(skip_serializing_if = "Option::is_none")]
pub currency_options: Option<
CurrencyMap<CreateCheckoutSessionShippingOptionsShippingRateDataFixedAmountCurrencyOptions>,
>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionSubscriptionDataInvoiceSettingsIssuer {
#[serde(skip_serializing_if = "Option::is_none")]
pub account: Option<String>,
#[serde(rename = "type")]
pub type_: CreateCheckoutSessionSubscriptionDataInvoiceSettingsIssuerType,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionSubscriptionDataTrialSettingsEndBehavior {
pub missing_payment_method:
CreateCheckoutSessionSubscriptionDataTrialSettingsEndBehaviorMissingPaymentMethod,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceBankTransferEuBankTransfer {
pub country: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionShippingOptionsShippingRateDataDeliveryEstimateMaximum {
pub unit: CreateCheckoutSessionShippingOptionsShippingRateDataDeliveryEstimateMaximumUnit,
pub value: i64,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionShippingOptionsShippingRateDataDeliveryEstimateMinimum {
pub unit: CreateCheckoutSessionShippingOptionsShippingRateDataDeliveryEstimateMinimumUnit,
pub value: i64,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateCheckoutSessionShippingOptionsShippingRateDataFixedAmountCurrencyOptions {
pub amount: i64,
#[serde(skip_serializing_if = "Option::is_none")]
pub tax_behavior: Option<
CreateCheckoutSessionShippingOptionsShippingRateDataFixedAmountCurrencyOptionsTaxBehavior,
>,
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutAcssDebitMandateOptionsDefaultFor {
Invoice,
Subscription,
}
impl CheckoutAcssDebitMandateOptionsDefaultFor {
pub fn as_str(self) -> &'static str {
match self {
CheckoutAcssDebitMandateOptionsDefaultFor::Invoice => "invoice",
CheckoutAcssDebitMandateOptionsDefaultFor::Subscription => "subscription",
}
}
}
impl AsRef<str> for CheckoutAcssDebitMandateOptionsDefaultFor {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutAcssDebitMandateOptionsDefaultFor {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutAcssDebitMandateOptionsDefaultFor {
fn default() -> Self {
Self::Invoice
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutAcssDebitMandateOptionsPaymentSchedule {
Combined,
Interval,
Sporadic,
}
impl CheckoutAcssDebitMandateOptionsPaymentSchedule {
pub fn as_str(self) -> &'static str {
match self {
CheckoutAcssDebitMandateOptionsPaymentSchedule::Combined => "combined",
CheckoutAcssDebitMandateOptionsPaymentSchedule::Interval => "interval",
CheckoutAcssDebitMandateOptionsPaymentSchedule::Sporadic => "sporadic",
}
}
}
impl AsRef<str> for CheckoutAcssDebitMandateOptionsPaymentSchedule {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutAcssDebitMandateOptionsPaymentSchedule {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutAcssDebitMandateOptionsPaymentSchedule {
fn default() -> Self {
Self::Combined
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutAcssDebitMandateOptionsTransactionType {
Business,
Personal,
}
impl CheckoutAcssDebitMandateOptionsTransactionType {
pub fn as_str(self) -> &'static str {
match self {
CheckoutAcssDebitMandateOptionsTransactionType::Business => "business",
CheckoutAcssDebitMandateOptionsTransactionType::Personal => "personal",
}
}
}
impl AsRef<str> for CheckoutAcssDebitMandateOptionsTransactionType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutAcssDebitMandateOptionsTransactionType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutAcssDebitMandateOptionsTransactionType {
fn default() -> Self {
Self::Business
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutAcssDebitPaymentMethodOptionsSetupFutureUsage {
None,
OffSession,
OnSession,
}
impl CheckoutAcssDebitPaymentMethodOptionsSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CheckoutAcssDebitPaymentMethodOptionsSetupFutureUsage::None => "none",
CheckoutAcssDebitPaymentMethodOptionsSetupFutureUsage::OffSession => "off_session",
CheckoutAcssDebitPaymentMethodOptionsSetupFutureUsage::OnSession => "on_session",
}
}
}
impl AsRef<str> for CheckoutAcssDebitPaymentMethodOptionsSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutAcssDebitPaymentMethodOptionsSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutAcssDebitPaymentMethodOptionsSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutAcssDebitPaymentMethodOptionsVerificationMethod {
Automatic,
Instant,
Microdeposits,
}
impl CheckoutAcssDebitPaymentMethodOptionsVerificationMethod {
pub fn as_str(self) -> &'static str {
match self {
CheckoutAcssDebitPaymentMethodOptionsVerificationMethod::Automatic => "automatic",
CheckoutAcssDebitPaymentMethodOptionsVerificationMethod::Instant => "instant",
CheckoutAcssDebitPaymentMethodOptionsVerificationMethod::Microdeposits => {
"microdeposits"
}
}
}
}
impl AsRef<str> for CheckoutAcssDebitPaymentMethodOptionsVerificationMethod {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutAcssDebitPaymentMethodOptionsVerificationMethod {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutAcssDebitPaymentMethodOptionsVerificationMethod {
fn default() -> Self {
Self::Automatic
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutAffirmPaymentMethodOptionsSetupFutureUsage {
None,
}
impl CheckoutAffirmPaymentMethodOptionsSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CheckoutAffirmPaymentMethodOptionsSetupFutureUsage::None => "none",
}
}
}
impl AsRef<str> for CheckoutAffirmPaymentMethodOptionsSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutAffirmPaymentMethodOptionsSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutAffirmPaymentMethodOptionsSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutAfterpayClearpayPaymentMethodOptionsSetupFutureUsage {
None,
}
impl CheckoutAfterpayClearpayPaymentMethodOptionsSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CheckoutAfterpayClearpayPaymentMethodOptionsSetupFutureUsage::None => "none",
}
}
}
impl AsRef<str> for CheckoutAfterpayClearpayPaymentMethodOptionsSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutAfterpayClearpayPaymentMethodOptionsSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutAfterpayClearpayPaymentMethodOptionsSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutAlipayPaymentMethodOptionsSetupFutureUsage {
None,
}
impl CheckoutAlipayPaymentMethodOptionsSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CheckoutAlipayPaymentMethodOptionsSetupFutureUsage::None => "none",
}
}
}
impl AsRef<str> for CheckoutAlipayPaymentMethodOptionsSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutAlipayPaymentMethodOptionsSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutAlipayPaymentMethodOptionsSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutAuBecsDebitPaymentMethodOptionsSetupFutureUsage {
None,
}
impl CheckoutAuBecsDebitPaymentMethodOptionsSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CheckoutAuBecsDebitPaymentMethodOptionsSetupFutureUsage::None => "none",
}
}
}
impl AsRef<str> for CheckoutAuBecsDebitPaymentMethodOptionsSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutAuBecsDebitPaymentMethodOptionsSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutAuBecsDebitPaymentMethodOptionsSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutBacsDebitPaymentMethodOptionsSetupFutureUsage {
None,
OffSession,
OnSession,
}
impl CheckoutBacsDebitPaymentMethodOptionsSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CheckoutBacsDebitPaymentMethodOptionsSetupFutureUsage::None => "none",
CheckoutBacsDebitPaymentMethodOptionsSetupFutureUsage::OffSession => "off_session",
CheckoutBacsDebitPaymentMethodOptionsSetupFutureUsage::OnSession => "on_session",
}
}
}
impl AsRef<str> for CheckoutBacsDebitPaymentMethodOptionsSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutBacsDebitPaymentMethodOptionsSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutBacsDebitPaymentMethodOptionsSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutBancontactPaymentMethodOptionsSetupFutureUsage {
None,
}
impl CheckoutBancontactPaymentMethodOptionsSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CheckoutBancontactPaymentMethodOptionsSetupFutureUsage::None => "none",
}
}
}
impl AsRef<str> for CheckoutBancontactPaymentMethodOptionsSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutBancontactPaymentMethodOptionsSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutBancontactPaymentMethodOptionsSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutBoletoPaymentMethodOptionsSetupFutureUsage {
None,
OffSession,
OnSession,
}
impl CheckoutBoletoPaymentMethodOptionsSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CheckoutBoletoPaymentMethodOptionsSetupFutureUsage::None => "none",
CheckoutBoletoPaymentMethodOptionsSetupFutureUsage::OffSession => "off_session",
CheckoutBoletoPaymentMethodOptionsSetupFutureUsage::OnSession => "on_session",
}
}
}
impl AsRef<str> for CheckoutBoletoPaymentMethodOptionsSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutBoletoPaymentMethodOptionsSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutBoletoPaymentMethodOptionsSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutCardPaymentMethodOptionsSetupFutureUsage {
None,
OffSession,
OnSession,
}
impl CheckoutCardPaymentMethodOptionsSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CheckoutCardPaymentMethodOptionsSetupFutureUsage::None => "none",
CheckoutCardPaymentMethodOptionsSetupFutureUsage::OffSession => "off_session",
CheckoutCardPaymentMethodOptionsSetupFutureUsage::OnSession => "on_session",
}
}
}
impl AsRef<str> for CheckoutCardPaymentMethodOptionsSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutCardPaymentMethodOptionsSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutCardPaymentMethodOptionsSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutCashappPaymentMethodOptionsSetupFutureUsage {
None,
}
impl CheckoutCashappPaymentMethodOptionsSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CheckoutCashappPaymentMethodOptionsSetupFutureUsage::None => "none",
}
}
}
impl AsRef<str> for CheckoutCashappPaymentMethodOptionsSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutCashappPaymentMethodOptionsSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutCashappPaymentMethodOptionsSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutCustomerBalanceBankTransferPaymentMethodOptionsRequestedAddressTypes {
Aba,
Iban,
Sepa,
SortCode,
Spei,
Swift,
Zengin,
}
impl CheckoutCustomerBalanceBankTransferPaymentMethodOptionsRequestedAddressTypes {
pub fn as_str(self) -> &'static str {
match self {
CheckoutCustomerBalanceBankTransferPaymentMethodOptionsRequestedAddressTypes::Aba => "aba",
CheckoutCustomerBalanceBankTransferPaymentMethodOptionsRequestedAddressTypes::Iban => "iban",
CheckoutCustomerBalanceBankTransferPaymentMethodOptionsRequestedAddressTypes::Sepa => "sepa",
CheckoutCustomerBalanceBankTransferPaymentMethodOptionsRequestedAddressTypes::SortCode => "sort_code",
CheckoutCustomerBalanceBankTransferPaymentMethodOptionsRequestedAddressTypes::Spei => "spei",
CheckoutCustomerBalanceBankTransferPaymentMethodOptionsRequestedAddressTypes::Swift => "swift",
CheckoutCustomerBalanceBankTransferPaymentMethodOptionsRequestedAddressTypes::Zengin => "zengin",
}
}
}
impl AsRef<str> for CheckoutCustomerBalanceBankTransferPaymentMethodOptionsRequestedAddressTypes {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display
for CheckoutCustomerBalanceBankTransferPaymentMethodOptionsRequestedAddressTypes
{
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CheckoutCustomerBalanceBankTransferPaymentMethodOptionsRequestedAddressTypes
{
fn default() -> Self {
Self::Aba
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutCustomerBalanceBankTransferPaymentMethodOptionsType {
EuBankTransfer,
GbBankTransfer,
JpBankTransfer,
MxBankTransfer,
UsBankTransfer,
}
impl CheckoutCustomerBalanceBankTransferPaymentMethodOptionsType {
pub fn as_str(self) -> &'static str {
match self {
CheckoutCustomerBalanceBankTransferPaymentMethodOptionsType::EuBankTransfer => {
"eu_bank_transfer"
}
CheckoutCustomerBalanceBankTransferPaymentMethodOptionsType::GbBankTransfer => {
"gb_bank_transfer"
}
CheckoutCustomerBalanceBankTransferPaymentMethodOptionsType::JpBankTransfer => {
"jp_bank_transfer"
}
CheckoutCustomerBalanceBankTransferPaymentMethodOptionsType::MxBankTransfer => {
"mx_bank_transfer"
}
CheckoutCustomerBalanceBankTransferPaymentMethodOptionsType::UsBankTransfer => {
"us_bank_transfer"
}
}
}
}
impl AsRef<str> for CheckoutCustomerBalanceBankTransferPaymentMethodOptionsType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutCustomerBalanceBankTransferPaymentMethodOptionsType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutCustomerBalanceBankTransferPaymentMethodOptionsType {
fn default() -> Self {
Self::EuBankTransfer
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutCustomerBalancePaymentMethodOptionsFundingType {
BankTransfer,
}
impl CheckoutCustomerBalancePaymentMethodOptionsFundingType {
pub fn as_str(self) -> &'static str {
match self {
CheckoutCustomerBalancePaymentMethodOptionsFundingType::BankTransfer => "bank_transfer",
}
}
}
impl AsRef<str> for CheckoutCustomerBalancePaymentMethodOptionsFundingType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutCustomerBalancePaymentMethodOptionsFundingType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutCustomerBalancePaymentMethodOptionsFundingType {
fn default() -> Self {
Self::BankTransfer
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutCustomerBalancePaymentMethodOptionsSetupFutureUsage {
None,
}
impl CheckoutCustomerBalancePaymentMethodOptionsSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CheckoutCustomerBalancePaymentMethodOptionsSetupFutureUsage::None => "none",
}
}
}
impl AsRef<str> for CheckoutCustomerBalancePaymentMethodOptionsSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutCustomerBalancePaymentMethodOptionsSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutCustomerBalancePaymentMethodOptionsSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutEpsPaymentMethodOptionsSetupFutureUsage {
None,
}
impl CheckoutEpsPaymentMethodOptionsSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CheckoutEpsPaymentMethodOptionsSetupFutureUsage::None => "none",
}
}
}
impl AsRef<str> for CheckoutEpsPaymentMethodOptionsSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutEpsPaymentMethodOptionsSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutEpsPaymentMethodOptionsSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutFpxPaymentMethodOptionsSetupFutureUsage {
None,
}
impl CheckoutFpxPaymentMethodOptionsSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CheckoutFpxPaymentMethodOptionsSetupFutureUsage::None => "none",
}
}
}
impl AsRef<str> for CheckoutFpxPaymentMethodOptionsSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutFpxPaymentMethodOptionsSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutFpxPaymentMethodOptionsSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutGiropayPaymentMethodOptionsSetupFutureUsage {
None,
}
impl CheckoutGiropayPaymentMethodOptionsSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CheckoutGiropayPaymentMethodOptionsSetupFutureUsage::None => "none",
}
}
}
impl AsRef<str> for CheckoutGiropayPaymentMethodOptionsSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutGiropayPaymentMethodOptionsSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutGiropayPaymentMethodOptionsSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutGrabPayPaymentMethodOptionsSetupFutureUsage {
None,
}
impl CheckoutGrabPayPaymentMethodOptionsSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CheckoutGrabPayPaymentMethodOptionsSetupFutureUsage::None => "none",
}
}
}
impl AsRef<str> for CheckoutGrabPayPaymentMethodOptionsSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutGrabPayPaymentMethodOptionsSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutGrabPayPaymentMethodOptionsSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutIdealPaymentMethodOptionsSetupFutureUsage {
None,
}
impl CheckoutIdealPaymentMethodOptionsSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CheckoutIdealPaymentMethodOptionsSetupFutureUsage::None => "none",
}
}
}
impl AsRef<str> for CheckoutIdealPaymentMethodOptionsSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutIdealPaymentMethodOptionsSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutIdealPaymentMethodOptionsSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutKlarnaPaymentMethodOptionsSetupFutureUsage {
None,
OffSession,
OnSession,
}
impl CheckoutKlarnaPaymentMethodOptionsSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CheckoutKlarnaPaymentMethodOptionsSetupFutureUsage::None => "none",
CheckoutKlarnaPaymentMethodOptionsSetupFutureUsage::OffSession => "off_session",
CheckoutKlarnaPaymentMethodOptionsSetupFutureUsage::OnSession => "on_session",
}
}
}
impl AsRef<str> for CheckoutKlarnaPaymentMethodOptionsSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutKlarnaPaymentMethodOptionsSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutKlarnaPaymentMethodOptionsSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutKonbiniPaymentMethodOptionsSetupFutureUsage {
None,
}
impl CheckoutKonbiniPaymentMethodOptionsSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CheckoutKonbiniPaymentMethodOptionsSetupFutureUsage::None => "none",
}
}
}
impl AsRef<str> for CheckoutKonbiniPaymentMethodOptionsSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutKonbiniPaymentMethodOptionsSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutKonbiniPaymentMethodOptionsSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutLinkPaymentMethodOptionsSetupFutureUsage {
None,
OffSession,
}
impl CheckoutLinkPaymentMethodOptionsSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CheckoutLinkPaymentMethodOptionsSetupFutureUsage::None => "none",
CheckoutLinkPaymentMethodOptionsSetupFutureUsage::OffSession => "off_session",
}
}
}
impl AsRef<str> for CheckoutLinkPaymentMethodOptionsSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutLinkPaymentMethodOptionsSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutLinkPaymentMethodOptionsSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutOxxoPaymentMethodOptionsSetupFutureUsage {
None,
}
impl CheckoutOxxoPaymentMethodOptionsSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CheckoutOxxoPaymentMethodOptionsSetupFutureUsage::None => "none",
}
}
}
impl AsRef<str> for CheckoutOxxoPaymentMethodOptionsSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutOxxoPaymentMethodOptionsSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutOxxoPaymentMethodOptionsSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutP24PaymentMethodOptionsSetupFutureUsage {
None,
}
impl CheckoutP24PaymentMethodOptionsSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CheckoutP24PaymentMethodOptionsSetupFutureUsage::None => "none",
}
}
}
impl AsRef<str> for CheckoutP24PaymentMethodOptionsSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutP24PaymentMethodOptionsSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutP24PaymentMethodOptionsSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutPaynowPaymentMethodOptionsSetupFutureUsage {
None,
}
impl CheckoutPaynowPaymentMethodOptionsSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CheckoutPaynowPaymentMethodOptionsSetupFutureUsage::None => "none",
}
}
}
impl AsRef<str> for CheckoutPaynowPaymentMethodOptionsSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutPaynowPaymentMethodOptionsSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutPaynowPaymentMethodOptionsSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutPaypalPaymentMethodOptionsCaptureMethod {
Manual,
}
impl CheckoutPaypalPaymentMethodOptionsCaptureMethod {
pub fn as_str(self) -> &'static str {
match self {
CheckoutPaypalPaymentMethodOptionsCaptureMethod::Manual => "manual",
}
}
}
impl AsRef<str> for CheckoutPaypalPaymentMethodOptionsCaptureMethod {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutPaypalPaymentMethodOptionsCaptureMethod {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutPaypalPaymentMethodOptionsCaptureMethod {
fn default() -> Self {
Self::Manual
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutPaypalPaymentMethodOptionsSetupFutureUsage {
None,
OffSession,
}
impl CheckoutPaypalPaymentMethodOptionsSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CheckoutPaypalPaymentMethodOptionsSetupFutureUsage::None => "none",
CheckoutPaypalPaymentMethodOptionsSetupFutureUsage::OffSession => "off_session",
}
}
}
impl AsRef<str> for CheckoutPaypalPaymentMethodOptionsSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutPaypalPaymentMethodOptionsSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutPaypalPaymentMethodOptionsSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutSepaDebitPaymentMethodOptionsSetupFutureUsage {
None,
OffSession,
OnSession,
}
impl CheckoutSepaDebitPaymentMethodOptionsSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CheckoutSepaDebitPaymentMethodOptionsSetupFutureUsage::None => "none",
CheckoutSepaDebitPaymentMethodOptionsSetupFutureUsage::OffSession => "off_session",
CheckoutSepaDebitPaymentMethodOptionsSetupFutureUsage::OnSession => "on_session",
}
}
}
impl AsRef<str> for CheckoutSepaDebitPaymentMethodOptionsSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutSepaDebitPaymentMethodOptionsSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutSepaDebitPaymentMethodOptionsSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutSessionBillingAddressCollection {
Auto,
Required,
}
impl CheckoutSessionBillingAddressCollection {
pub fn as_str(self) -> &'static str {
match self {
CheckoutSessionBillingAddressCollection::Auto => "auto",
CheckoutSessionBillingAddressCollection::Required => "required",
}
}
}
impl AsRef<str> for CheckoutSessionBillingAddressCollection {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutSessionBillingAddressCollection {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutSessionBillingAddressCollection {
fn default() -> Self {
Self::Auto
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutSessionCustomerCreation {
Always,
IfRequired,
}
impl CheckoutSessionCustomerCreation {
pub fn as_str(self) -> &'static str {
match self {
CheckoutSessionCustomerCreation::Always => "always",
CheckoutSessionCustomerCreation::IfRequired => "if_required",
}
}
}
impl AsRef<str> for CheckoutSessionCustomerCreation {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutSessionCustomerCreation {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutSessionCustomerCreation {
fn default() -> Self {
Self::Always
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutSessionLocale {
Auto,
Bg,
Cs,
Da,
De,
El,
En,
#[serde(rename = "en-GB")]
EnGb,
Es,
#[serde(rename = "es-419")]
Es419,
Et,
Fi,
Fil,
Fr,
#[serde(rename = "fr-CA")]
FrCa,
Hr,
Hu,
Id,
It,
Ja,
Ko,
Lt,
Lv,
Ms,
Mt,
Nb,
Nl,
Pl,
Pt,
#[serde(rename = "pt-BR")]
PtBr,
Ro,
Ru,
Sk,
Sl,
Sv,
Th,
Tr,
Vi,
Zh,
#[serde(rename = "zh-HK")]
ZhHk,
#[serde(rename = "zh-TW")]
ZhTw,
}
impl CheckoutSessionLocale {
pub fn as_str(self) -> &'static str {
match self {
CheckoutSessionLocale::Auto => "auto",
CheckoutSessionLocale::Bg => "bg",
CheckoutSessionLocale::Cs => "cs",
CheckoutSessionLocale::Da => "da",
CheckoutSessionLocale::De => "de",
CheckoutSessionLocale::El => "el",
CheckoutSessionLocale::En => "en",
CheckoutSessionLocale::EnGb => "en-GB",
CheckoutSessionLocale::Es => "es",
CheckoutSessionLocale::Es419 => "es-419",
CheckoutSessionLocale::Et => "et",
CheckoutSessionLocale::Fi => "fi",
CheckoutSessionLocale::Fil => "fil",
CheckoutSessionLocale::Fr => "fr",
CheckoutSessionLocale::FrCa => "fr-CA",
CheckoutSessionLocale::Hr => "hr",
CheckoutSessionLocale::Hu => "hu",
CheckoutSessionLocale::Id => "id",
CheckoutSessionLocale::It => "it",
CheckoutSessionLocale::Ja => "ja",
CheckoutSessionLocale::Ko => "ko",
CheckoutSessionLocale::Lt => "lt",
CheckoutSessionLocale::Lv => "lv",
CheckoutSessionLocale::Ms => "ms",
CheckoutSessionLocale::Mt => "mt",
CheckoutSessionLocale::Nb => "nb",
CheckoutSessionLocale::Nl => "nl",
CheckoutSessionLocale::Pl => "pl",
CheckoutSessionLocale::Pt => "pt",
CheckoutSessionLocale::PtBr => "pt-BR",
CheckoutSessionLocale::Ro => "ro",
CheckoutSessionLocale::Ru => "ru",
CheckoutSessionLocale::Sk => "sk",
CheckoutSessionLocale::Sl => "sl",
CheckoutSessionLocale::Sv => "sv",
CheckoutSessionLocale::Th => "th",
CheckoutSessionLocale::Tr => "tr",
CheckoutSessionLocale::Vi => "vi",
CheckoutSessionLocale::Zh => "zh",
CheckoutSessionLocale::ZhHk => "zh-HK",
CheckoutSessionLocale::ZhTw => "zh-TW",
}
}
}
impl AsRef<str> for CheckoutSessionLocale {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutSessionLocale {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutSessionLocale {
fn default() -> Self {
Self::Auto
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutSessionMode {
Payment,
Setup,
Subscription,
}
impl CheckoutSessionMode {
pub fn as_str(self) -> &'static str {
match self {
CheckoutSessionMode::Payment => "payment",
CheckoutSessionMode::Setup => "setup",
CheckoutSessionMode::Subscription => "subscription",
}
}
}
impl AsRef<str> for CheckoutSessionMode {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutSessionMode {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutSessionMode {
fn default() -> Self {
Self::Payment
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutSessionPaymentMethodCollection {
Always,
IfRequired,
}
impl CheckoutSessionPaymentMethodCollection {
pub fn as_str(self) -> &'static str {
match self {
CheckoutSessionPaymentMethodCollection::Always => "always",
CheckoutSessionPaymentMethodCollection::IfRequired => "if_required",
}
}
}
impl AsRef<str> for CheckoutSessionPaymentMethodCollection {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutSessionPaymentMethodCollection {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutSessionPaymentMethodCollection {
fn default() -> Self {
Self::Always
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutSessionPaymentStatus {
NoPaymentRequired,
Paid,
Unpaid,
}
impl CheckoutSessionPaymentStatus {
pub fn as_str(self) -> &'static str {
match self {
CheckoutSessionPaymentStatus::NoPaymentRequired => "no_payment_required",
CheckoutSessionPaymentStatus::Paid => "paid",
CheckoutSessionPaymentStatus::Unpaid => "unpaid",
}
}
}
impl AsRef<str> for CheckoutSessionPaymentStatus {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutSessionPaymentStatus {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutSessionPaymentStatus {
fn default() -> Self {
Self::NoPaymentRequired
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutSessionRedirectOnCompletion {
Always,
IfRequired,
Never,
}
impl CheckoutSessionRedirectOnCompletion {
pub fn as_str(self) -> &'static str {
match self {
CheckoutSessionRedirectOnCompletion::Always => "always",
CheckoutSessionRedirectOnCompletion::IfRequired => "if_required",
CheckoutSessionRedirectOnCompletion::Never => "never",
}
}
}
impl AsRef<str> for CheckoutSessionRedirectOnCompletion {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutSessionRedirectOnCompletion {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutSessionRedirectOnCompletion {
fn default() -> Self {
Self::Always
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutSessionStatus {
Complete,
Expired,
Open,
}
impl CheckoutSessionStatus {
pub fn as_str(self) -> &'static str {
match self {
CheckoutSessionStatus::Complete => "complete",
CheckoutSessionStatus::Expired => "expired",
CheckoutSessionStatus::Open => "open",
}
}
}
impl AsRef<str> for CheckoutSessionStatus {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutSessionStatus {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutSessionStatus {
fn default() -> Self {
Self::Complete
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutSessionSubmitType {
Auto,
Book,
Donate,
Pay,
}
impl CheckoutSessionSubmitType {
pub fn as_str(self) -> &'static str {
match self {
CheckoutSessionSubmitType::Auto => "auto",
CheckoutSessionSubmitType::Book => "book",
CheckoutSessionSubmitType::Donate => "donate",
CheckoutSessionSubmitType::Pay => "pay",
}
}
}
impl AsRef<str> for CheckoutSessionSubmitType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutSessionSubmitType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutSessionSubmitType {
fn default() -> Self {
Self::Auto
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutSessionUiMode {
Embedded,
Hosted,
}
impl CheckoutSessionUiMode {
pub fn as_str(self) -> &'static str {
match self {
CheckoutSessionUiMode::Embedded => "embedded",
CheckoutSessionUiMode::Hosted => "hosted",
}
}
}
impl AsRef<str> for CheckoutSessionUiMode {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutSessionUiMode {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutSessionUiMode {
fn default() -> Self {
Self::Embedded
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutSofortPaymentMethodOptionsSetupFutureUsage {
None,
}
impl CheckoutSofortPaymentMethodOptionsSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CheckoutSofortPaymentMethodOptionsSetupFutureUsage::None => "none",
}
}
}
impl AsRef<str> for CheckoutSofortPaymentMethodOptionsSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutSofortPaymentMethodOptionsSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutSofortPaymentMethodOptionsSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutUsBankAccountPaymentMethodOptionsSetupFutureUsage {
None,
OffSession,
OnSession,
}
impl CheckoutUsBankAccountPaymentMethodOptionsSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CheckoutUsBankAccountPaymentMethodOptionsSetupFutureUsage::None => "none",
CheckoutUsBankAccountPaymentMethodOptionsSetupFutureUsage::OffSession => "off_session",
CheckoutUsBankAccountPaymentMethodOptionsSetupFutureUsage::OnSession => "on_session",
}
}
}
impl AsRef<str> for CheckoutUsBankAccountPaymentMethodOptionsSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutUsBankAccountPaymentMethodOptionsSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutUsBankAccountPaymentMethodOptionsSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CheckoutUsBankAccountPaymentMethodOptionsVerificationMethod {
Automatic,
Instant,
}
impl CheckoutUsBankAccountPaymentMethodOptionsVerificationMethod {
pub fn as_str(self) -> &'static str {
match self {
CheckoutUsBankAccountPaymentMethodOptionsVerificationMethod::Automatic => "automatic",
CheckoutUsBankAccountPaymentMethodOptionsVerificationMethod::Instant => "instant",
}
}
}
impl AsRef<str> for CheckoutUsBankAccountPaymentMethodOptionsVerificationMethod {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CheckoutUsBankAccountPaymentMethodOptionsVerificationMethod {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CheckoutUsBankAccountPaymentMethodOptionsVerificationMethod {
fn default() -> Self {
Self::Automatic
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionAutomaticTaxLiabilityType {
Account,
#[serde(rename = "self")]
Self_,
}
impl CreateCheckoutSessionAutomaticTaxLiabilityType {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionAutomaticTaxLiabilityType::Account => "account",
CreateCheckoutSessionAutomaticTaxLiabilityType::Self_ => "self",
}
}
}
impl AsRef<str> for CreateCheckoutSessionAutomaticTaxLiabilityType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionAutomaticTaxLiabilityType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionAutomaticTaxLiabilityType {
fn default() -> Self {
Self::Account
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionConsentCollectionPaymentMethodReuseAgreementPosition {
Auto,
Hidden,
}
impl CreateCheckoutSessionConsentCollectionPaymentMethodReuseAgreementPosition {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionConsentCollectionPaymentMethodReuseAgreementPosition::Auto => {
"auto"
}
CreateCheckoutSessionConsentCollectionPaymentMethodReuseAgreementPosition::Hidden => {
"hidden"
}
}
}
}
impl AsRef<str> for CreateCheckoutSessionConsentCollectionPaymentMethodReuseAgreementPosition {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display
for CreateCheckoutSessionConsentCollectionPaymentMethodReuseAgreementPosition
{
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CreateCheckoutSessionConsentCollectionPaymentMethodReuseAgreementPosition
{
fn default() -> Self {
Self::Auto
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionConsentCollectionPromotions {
Auto,
None,
}
impl CreateCheckoutSessionConsentCollectionPromotions {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionConsentCollectionPromotions::Auto => "auto",
CreateCheckoutSessionConsentCollectionPromotions::None => "none",
}
}
}
impl AsRef<str> for CreateCheckoutSessionConsentCollectionPromotions {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionConsentCollectionPromotions {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionConsentCollectionPromotions {
fn default() -> Self {
Self::Auto
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionConsentCollectionTermsOfService {
None,
Required,
}
impl CreateCheckoutSessionConsentCollectionTermsOfService {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionConsentCollectionTermsOfService::None => "none",
CreateCheckoutSessionConsentCollectionTermsOfService::Required => "required",
}
}
}
impl AsRef<str> for CreateCheckoutSessionConsentCollectionTermsOfService {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionConsentCollectionTermsOfService {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionConsentCollectionTermsOfService {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionCustomFieldsLabelType {
Custom,
}
impl CreateCheckoutSessionCustomFieldsLabelType {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionCustomFieldsLabelType::Custom => "custom",
}
}
}
impl AsRef<str> for CreateCheckoutSessionCustomFieldsLabelType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionCustomFieldsLabelType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionCustomFieldsLabelType {
fn default() -> Self {
Self::Custom
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionCustomFieldsType {
Dropdown,
Numeric,
Text,
}
impl CreateCheckoutSessionCustomFieldsType {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionCustomFieldsType::Dropdown => "dropdown",
CreateCheckoutSessionCustomFieldsType::Numeric => "numeric",
CreateCheckoutSessionCustomFieldsType::Text => "text",
}
}
}
impl AsRef<str> for CreateCheckoutSessionCustomFieldsType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionCustomFieldsType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionCustomFieldsType {
fn default() -> Self {
Self::Dropdown
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionCustomerUpdateAddress {
Auto,
Never,
}
impl CreateCheckoutSessionCustomerUpdateAddress {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionCustomerUpdateAddress::Auto => "auto",
CreateCheckoutSessionCustomerUpdateAddress::Never => "never",
}
}
}
impl AsRef<str> for CreateCheckoutSessionCustomerUpdateAddress {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionCustomerUpdateAddress {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionCustomerUpdateAddress {
fn default() -> Self {
Self::Auto
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionCustomerUpdateName {
Auto,
Never,
}
impl CreateCheckoutSessionCustomerUpdateName {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionCustomerUpdateName::Auto => "auto",
CreateCheckoutSessionCustomerUpdateName::Never => "never",
}
}
}
impl AsRef<str> for CreateCheckoutSessionCustomerUpdateName {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionCustomerUpdateName {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionCustomerUpdateName {
fn default() -> Self {
Self::Auto
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionCustomerUpdateShipping {
Auto,
Never,
}
impl CreateCheckoutSessionCustomerUpdateShipping {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionCustomerUpdateShipping::Auto => "auto",
CreateCheckoutSessionCustomerUpdateShipping::Never => "never",
}
}
}
impl AsRef<str> for CreateCheckoutSessionCustomerUpdateShipping {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionCustomerUpdateShipping {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionCustomerUpdateShipping {
fn default() -> Self {
Self::Auto
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionInvoiceCreationInvoiceDataIssuerType {
Account,
#[serde(rename = "self")]
Self_,
}
impl CreateCheckoutSessionInvoiceCreationInvoiceDataIssuerType {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionInvoiceCreationInvoiceDataIssuerType::Account => "account",
CreateCheckoutSessionInvoiceCreationInvoiceDataIssuerType::Self_ => "self",
}
}
}
impl AsRef<str> for CreateCheckoutSessionInvoiceCreationInvoiceDataIssuerType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionInvoiceCreationInvoiceDataIssuerType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionInvoiceCreationInvoiceDataIssuerType {
fn default() -> Self {
Self::Account
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionInvoiceCreationInvoiceDataRenderingOptionsAmountTaxDisplay {
ExcludeTax,
IncludeInclusiveTax,
}
impl CreateCheckoutSessionInvoiceCreationInvoiceDataRenderingOptionsAmountTaxDisplay {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionInvoiceCreationInvoiceDataRenderingOptionsAmountTaxDisplay::ExcludeTax => "exclude_tax",
CreateCheckoutSessionInvoiceCreationInvoiceDataRenderingOptionsAmountTaxDisplay::IncludeInclusiveTax => "include_inclusive_tax",
}
}
}
impl AsRef<str>
for CreateCheckoutSessionInvoiceCreationInvoiceDataRenderingOptionsAmountTaxDisplay
{
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display
for CreateCheckoutSessionInvoiceCreationInvoiceDataRenderingOptionsAmountTaxDisplay
{
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CreateCheckoutSessionInvoiceCreationInvoiceDataRenderingOptionsAmountTaxDisplay
{
fn default() -> Self {
Self::ExcludeTax
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionLineItemsPriceDataRecurringInterval {
Day,
Month,
Week,
Year,
}
impl CreateCheckoutSessionLineItemsPriceDataRecurringInterval {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionLineItemsPriceDataRecurringInterval::Day => "day",
CreateCheckoutSessionLineItemsPriceDataRecurringInterval::Month => "month",
CreateCheckoutSessionLineItemsPriceDataRecurringInterval::Week => "week",
CreateCheckoutSessionLineItemsPriceDataRecurringInterval::Year => "year",
}
}
}
impl AsRef<str> for CreateCheckoutSessionLineItemsPriceDataRecurringInterval {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionLineItemsPriceDataRecurringInterval {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionLineItemsPriceDataRecurringInterval {
fn default() -> Self {
Self::Day
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionLineItemsPriceDataTaxBehavior {
Exclusive,
Inclusive,
Unspecified,
}
impl CreateCheckoutSessionLineItemsPriceDataTaxBehavior {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionLineItemsPriceDataTaxBehavior::Exclusive => "exclusive",
CreateCheckoutSessionLineItemsPriceDataTaxBehavior::Inclusive => "inclusive",
CreateCheckoutSessionLineItemsPriceDataTaxBehavior::Unspecified => "unspecified",
}
}
}
impl AsRef<str> for CreateCheckoutSessionLineItemsPriceDataTaxBehavior {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionLineItemsPriceDataTaxBehavior {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionLineItemsPriceDataTaxBehavior {
fn default() -> Self {
Self::Exclusive
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentIntentDataCaptureMethod {
Automatic,
AutomaticAsync,
Manual,
}
impl CreateCheckoutSessionPaymentIntentDataCaptureMethod {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentIntentDataCaptureMethod::Automatic => "automatic",
CreateCheckoutSessionPaymentIntentDataCaptureMethod::AutomaticAsync => {
"automatic_async"
}
CreateCheckoutSessionPaymentIntentDataCaptureMethod::Manual => "manual",
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentIntentDataCaptureMethod {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionPaymentIntentDataCaptureMethod {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionPaymentIntentDataCaptureMethod {
fn default() -> Self {
Self::Automatic
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentIntentDataSetupFutureUsage {
OffSession,
OnSession,
}
impl CreateCheckoutSessionPaymentIntentDataSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentIntentDataSetupFutureUsage::OffSession => "off_session",
CreateCheckoutSessionPaymentIntentDataSetupFutureUsage::OnSession => "on_session",
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentIntentDataSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionPaymentIntentDataSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionPaymentIntentDataSetupFutureUsage {
fn default() -> Self {
Self::OffSession
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsAcssDebitMandateOptionsDefaultFor {
Invoice,
Subscription,
}
impl CreateCheckoutSessionPaymentMethodOptionsAcssDebitMandateOptionsDefaultFor {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsAcssDebitMandateOptionsDefaultFor::Invoice => "invoice",
CreateCheckoutSessionPaymentMethodOptionsAcssDebitMandateOptionsDefaultFor::Subscription => "subscription",
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsAcssDebitMandateOptionsDefaultFor {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display
for CreateCheckoutSessionPaymentMethodOptionsAcssDebitMandateOptionsDefaultFor
{
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CreateCheckoutSessionPaymentMethodOptionsAcssDebitMandateOptionsDefaultFor
{
fn default() -> Self {
Self::Invoice
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsAcssDebitMandateOptionsPaymentSchedule {
Combined,
Interval,
Sporadic,
}
impl CreateCheckoutSessionPaymentMethodOptionsAcssDebitMandateOptionsPaymentSchedule {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsAcssDebitMandateOptionsPaymentSchedule::Combined => "combined",
CreateCheckoutSessionPaymentMethodOptionsAcssDebitMandateOptionsPaymentSchedule::Interval => "interval",
CreateCheckoutSessionPaymentMethodOptionsAcssDebitMandateOptionsPaymentSchedule::Sporadic => "sporadic",
}
}
}
impl AsRef<str>
for CreateCheckoutSessionPaymentMethodOptionsAcssDebitMandateOptionsPaymentSchedule
{
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display
for CreateCheckoutSessionPaymentMethodOptionsAcssDebitMandateOptionsPaymentSchedule
{
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CreateCheckoutSessionPaymentMethodOptionsAcssDebitMandateOptionsPaymentSchedule
{
fn default() -> Self {
Self::Combined
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsAcssDebitMandateOptionsTransactionType {
Business,
Personal,
}
impl CreateCheckoutSessionPaymentMethodOptionsAcssDebitMandateOptionsTransactionType {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsAcssDebitMandateOptionsTransactionType::Business => "business",
CreateCheckoutSessionPaymentMethodOptionsAcssDebitMandateOptionsTransactionType::Personal => "personal",
}
}
}
impl AsRef<str>
for CreateCheckoutSessionPaymentMethodOptionsAcssDebitMandateOptionsTransactionType
{
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display
for CreateCheckoutSessionPaymentMethodOptionsAcssDebitMandateOptionsTransactionType
{
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CreateCheckoutSessionPaymentMethodOptionsAcssDebitMandateOptionsTransactionType
{
fn default() -> Self {
Self::Business
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsAcssDebitSetupFutureUsage {
None,
OffSession,
OnSession,
}
impl CreateCheckoutSessionPaymentMethodOptionsAcssDebitSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsAcssDebitSetupFutureUsage::None => "none",
CreateCheckoutSessionPaymentMethodOptionsAcssDebitSetupFutureUsage::OffSession => {
"off_session"
}
CreateCheckoutSessionPaymentMethodOptionsAcssDebitSetupFutureUsage::OnSession => {
"on_session"
}
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsAcssDebitSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionPaymentMethodOptionsAcssDebitSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionPaymentMethodOptionsAcssDebitSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsAcssDebitVerificationMethod {
Automatic,
Instant,
Microdeposits,
}
impl CreateCheckoutSessionPaymentMethodOptionsAcssDebitVerificationMethod {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsAcssDebitVerificationMethod::Automatic => {
"automatic"
}
CreateCheckoutSessionPaymentMethodOptionsAcssDebitVerificationMethod::Instant => {
"instant"
}
CreateCheckoutSessionPaymentMethodOptionsAcssDebitVerificationMethod::Microdeposits => {
"microdeposits"
}
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsAcssDebitVerificationMethod {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionPaymentMethodOptionsAcssDebitVerificationMethod {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CreateCheckoutSessionPaymentMethodOptionsAcssDebitVerificationMethod
{
fn default() -> Self {
Self::Automatic
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsAffirmSetupFutureUsage {
None,
}
impl CreateCheckoutSessionPaymentMethodOptionsAffirmSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsAffirmSetupFutureUsage::None => "none",
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsAffirmSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionPaymentMethodOptionsAffirmSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionPaymentMethodOptionsAffirmSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsAfterpayClearpaySetupFutureUsage {
None,
}
impl CreateCheckoutSessionPaymentMethodOptionsAfterpayClearpaySetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsAfterpayClearpaySetupFutureUsage::None => {
"none"
}
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsAfterpayClearpaySetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display
for CreateCheckoutSessionPaymentMethodOptionsAfterpayClearpaySetupFutureUsage
{
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CreateCheckoutSessionPaymentMethodOptionsAfterpayClearpaySetupFutureUsage
{
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsAlipaySetupFutureUsage {
None,
}
impl CreateCheckoutSessionPaymentMethodOptionsAlipaySetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsAlipaySetupFutureUsage::None => "none",
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsAlipaySetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionPaymentMethodOptionsAlipaySetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionPaymentMethodOptionsAlipaySetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsAuBecsDebitSetupFutureUsage {
None,
}
impl CreateCheckoutSessionPaymentMethodOptionsAuBecsDebitSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsAuBecsDebitSetupFutureUsage::None => "none",
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsAuBecsDebitSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionPaymentMethodOptionsAuBecsDebitSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CreateCheckoutSessionPaymentMethodOptionsAuBecsDebitSetupFutureUsage
{
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsBacsDebitSetupFutureUsage {
None,
OffSession,
OnSession,
}
impl CreateCheckoutSessionPaymentMethodOptionsBacsDebitSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsBacsDebitSetupFutureUsage::None => "none",
CreateCheckoutSessionPaymentMethodOptionsBacsDebitSetupFutureUsage::OffSession => {
"off_session"
}
CreateCheckoutSessionPaymentMethodOptionsBacsDebitSetupFutureUsage::OnSession => {
"on_session"
}
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsBacsDebitSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionPaymentMethodOptionsBacsDebitSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionPaymentMethodOptionsBacsDebitSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsBancontactSetupFutureUsage {
None,
}
impl CreateCheckoutSessionPaymentMethodOptionsBancontactSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsBancontactSetupFutureUsage::None => "none",
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsBancontactSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionPaymentMethodOptionsBancontactSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionPaymentMethodOptionsBancontactSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsBoletoSetupFutureUsage {
None,
OffSession,
OnSession,
}
impl CreateCheckoutSessionPaymentMethodOptionsBoletoSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsBoletoSetupFutureUsage::None => "none",
CreateCheckoutSessionPaymentMethodOptionsBoletoSetupFutureUsage::OffSession => {
"off_session"
}
CreateCheckoutSessionPaymentMethodOptionsBoletoSetupFutureUsage::OnSession => {
"on_session"
}
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsBoletoSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionPaymentMethodOptionsBoletoSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionPaymentMethodOptionsBoletoSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsCardSetupFutureUsage {
OffSession,
OnSession,
}
impl CreateCheckoutSessionPaymentMethodOptionsCardSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsCardSetupFutureUsage::OffSession => {
"off_session"
}
CreateCheckoutSessionPaymentMethodOptionsCardSetupFutureUsage::OnSession => {
"on_session"
}
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsCardSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionPaymentMethodOptionsCardSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionPaymentMethodOptionsCardSetupFutureUsage {
fn default() -> Self {
Self::OffSession
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsCashappSetupFutureUsage {
None,
OffSession,
OnSession,
}
impl CreateCheckoutSessionPaymentMethodOptionsCashappSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsCashappSetupFutureUsage::None => "none",
CreateCheckoutSessionPaymentMethodOptionsCashappSetupFutureUsage::OffSession => {
"off_session"
}
CreateCheckoutSessionPaymentMethodOptionsCashappSetupFutureUsage::OnSession => {
"on_session"
}
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsCashappSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionPaymentMethodOptionsCashappSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionPaymentMethodOptionsCashappSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceBankTransferRequestedAddressTypes {
Aba,
Iban,
Sepa,
SortCode,
Spei,
Swift,
Zengin,
}
impl CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceBankTransferRequestedAddressTypes {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceBankTransferRequestedAddressTypes::Aba => "aba",
CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceBankTransferRequestedAddressTypes::Iban => "iban",
CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceBankTransferRequestedAddressTypes::Sepa => "sepa",
CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceBankTransferRequestedAddressTypes::SortCode => "sort_code",
CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceBankTransferRequestedAddressTypes::Spei => "spei",
CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceBankTransferRequestedAddressTypes::Swift => "swift",
CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceBankTransferRequestedAddressTypes::Zengin => "zengin",
}
}
}
impl AsRef<str>
for CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceBankTransferRequestedAddressTypes
{
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display
for CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceBankTransferRequestedAddressTypes
{
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceBankTransferRequestedAddressTypes
{
fn default() -> Self {
Self::Aba
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceBankTransferType {
EuBankTransfer,
GbBankTransfer,
JpBankTransfer,
MxBankTransfer,
UsBankTransfer,
}
impl CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceBankTransferType {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceBankTransferType::EuBankTransfer => "eu_bank_transfer",
CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceBankTransferType::GbBankTransfer => "gb_bank_transfer",
CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceBankTransferType::JpBankTransfer => "jp_bank_transfer",
CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceBankTransferType::MxBankTransfer => "mx_bank_transfer",
CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceBankTransferType::UsBankTransfer => "us_bank_transfer",
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceBankTransferType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display
for CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceBankTransferType
{
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceBankTransferType
{
fn default() -> Self {
Self::EuBankTransfer
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceFundingType {
BankTransfer,
}
impl CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceFundingType {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceFundingType::BankTransfer => {
"bank_transfer"
}
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceFundingType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceFundingType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceFundingType {
fn default() -> Self {
Self::BankTransfer
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceSetupFutureUsage {
None,
}
impl CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceSetupFutureUsage::None => {
"none"
}
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display
for CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceSetupFutureUsage
{
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CreateCheckoutSessionPaymentMethodOptionsCustomerBalanceSetupFutureUsage
{
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsEpsSetupFutureUsage {
None,
}
impl CreateCheckoutSessionPaymentMethodOptionsEpsSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsEpsSetupFutureUsage::None => "none",
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsEpsSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionPaymentMethodOptionsEpsSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionPaymentMethodOptionsEpsSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsFpxSetupFutureUsage {
None,
}
impl CreateCheckoutSessionPaymentMethodOptionsFpxSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsFpxSetupFutureUsage::None => "none",
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsFpxSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionPaymentMethodOptionsFpxSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionPaymentMethodOptionsFpxSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsGiropaySetupFutureUsage {
None,
}
impl CreateCheckoutSessionPaymentMethodOptionsGiropaySetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsGiropaySetupFutureUsage::None => "none",
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsGiropaySetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionPaymentMethodOptionsGiropaySetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionPaymentMethodOptionsGiropaySetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsGrabpaySetupFutureUsage {
None,
}
impl CreateCheckoutSessionPaymentMethodOptionsGrabpaySetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsGrabpaySetupFutureUsage::None => "none",
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsGrabpaySetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionPaymentMethodOptionsGrabpaySetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionPaymentMethodOptionsGrabpaySetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsIdealSetupFutureUsage {
None,
}
impl CreateCheckoutSessionPaymentMethodOptionsIdealSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsIdealSetupFutureUsage::None => "none",
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsIdealSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionPaymentMethodOptionsIdealSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionPaymentMethodOptionsIdealSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsKlarnaSetupFutureUsage {
None,
}
impl CreateCheckoutSessionPaymentMethodOptionsKlarnaSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsKlarnaSetupFutureUsage::None => "none",
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsKlarnaSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionPaymentMethodOptionsKlarnaSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionPaymentMethodOptionsKlarnaSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsKonbiniSetupFutureUsage {
None,
}
impl CreateCheckoutSessionPaymentMethodOptionsKonbiniSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsKonbiniSetupFutureUsage::None => "none",
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsKonbiniSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionPaymentMethodOptionsKonbiniSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionPaymentMethodOptionsKonbiniSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsLinkSetupFutureUsage {
None,
OffSession,
}
impl CreateCheckoutSessionPaymentMethodOptionsLinkSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsLinkSetupFutureUsage::None => "none",
CreateCheckoutSessionPaymentMethodOptionsLinkSetupFutureUsage::OffSession => {
"off_session"
}
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsLinkSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionPaymentMethodOptionsLinkSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionPaymentMethodOptionsLinkSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsOxxoSetupFutureUsage {
None,
}
impl CreateCheckoutSessionPaymentMethodOptionsOxxoSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsOxxoSetupFutureUsage::None => "none",
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsOxxoSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionPaymentMethodOptionsOxxoSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionPaymentMethodOptionsOxxoSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsP24SetupFutureUsage {
None,
}
impl CreateCheckoutSessionPaymentMethodOptionsP24SetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsP24SetupFutureUsage::None => "none",
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsP24SetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionPaymentMethodOptionsP24SetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionPaymentMethodOptionsP24SetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsPaynowSetupFutureUsage {
None,
}
impl CreateCheckoutSessionPaymentMethodOptionsPaynowSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsPaynowSetupFutureUsage::None => "none",
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsPaynowSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionPaymentMethodOptionsPaynowSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionPaymentMethodOptionsPaynowSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsPaypalCaptureMethod {
Manual,
}
impl CreateCheckoutSessionPaymentMethodOptionsPaypalCaptureMethod {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsPaypalCaptureMethod::Manual => "manual",
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsPaypalCaptureMethod {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionPaymentMethodOptionsPaypalCaptureMethod {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionPaymentMethodOptionsPaypalCaptureMethod {
fn default() -> Self {
Self::Manual
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsPaypalPreferredLocale {
#[serde(rename = "cs-CZ")]
CsCz,
#[serde(rename = "da-DK")]
DaDk,
#[serde(rename = "de-AT")]
DeAt,
#[serde(rename = "de-DE")]
DeDe,
#[serde(rename = "de-LU")]
DeLu,
#[serde(rename = "el-GR")]
ElGr,
#[serde(rename = "en-GB")]
EnGb,
#[serde(rename = "en-US")]
EnUs,
#[serde(rename = "es-ES")]
EsEs,
#[serde(rename = "fi-FI")]
FiFi,
#[serde(rename = "fr-BE")]
FrBe,
#[serde(rename = "fr-FR")]
FrFr,
#[serde(rename = "fr-LU")]
FrLu,
#[serde(rename = "hu-HU")]
HuHu,
#[serde(rename = "it-IT")]
ItIt,
#[serde(rename = "nl-BE")]
NlBe,
#[serde(rename = "nl-NL")]
NlNl,
#[serde(rename = "pl-PL")]
PlPl,
#[serde(rename = "pt-PT")]
PtPt,
#[serde(rename = "sk-SK")]
SkSk,
#[serde(rename = "sv-SE")]
SvSe,
}
impl CreateCheckoutSessionPaymentMethodOptionsPaypalPreferredLocale {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsPaypalPreferredLocale::CsCz => "cs-CZ",
CreateCheckoutSessionPaymentMethodOptionsPaypalPreferredLocale::DaDk => "da-DK",
CreateCheckoutSessionPaymentMethodOptionsPaypalPreferredLocale::DeAt => "de-AT",
CreateCheckoutSessionPaymentMethodOptionsPaypalPreferredLocale::DeDe => "de-DE",
CreateCheckoutSessionPaymentMethodOptionsPaypalPreferredLocale::DeLu => "de-LU",
CreateCheckoutSessionPaymentMethodOptionsPaypalPreferredLocale::ElGr => "el-GR",
CreateCheckoutSessionPaymentMethodOptionsPaypalPreferredLocale::EnGb => "en-GB",
CreateCheckoutSessionPaymentMethodOptionsPaypalPreferredLocale::EnUs => "en-US",
CreateCheckoutSessionPaymentMethodOptionsPaypalPreferredLocale::EsEs => "es-ES",
CreateCheckoutSessionPaymentMethodOptionsPaypalPreferredLocale::FiFi => "fi-FI",
CreateCheckoutSessionPaymentMethodOptionsPaypalPreferredLocale::FrBe => "fr-BE",
CreateCheckoutSessionPaymentMethodOptionsPaypalPreferredLocale::FrFr => "fr-FR",
CreateCheckoutSessionPaymentMethodOptionsPaypalPreferredLocale::FrLu => "fr-LU",
CreateCheckoutSessionPaymentMethodOptionsPaypalPreferredLocale::HuHu => "hu-HU",
CreateCheckoutSessionPaymentMethodOptionsPaypalPreferredLocale::ItIt => "it-IT",
CreateCheckoutSessionPaymentMethodOptionsPaypalPreferredLocale::NlBe => "nl-BE",
CreateCheckoutSessionPaymentMethodOptionsPaypalPreferredLocale::NlNl => "nl-NL",
CreateCheckoutSessionPaymentMethodOptionsPaypalPreferredLocale::PlPl => "pl-PL",
CreateCheckoutSessionPaymentMethodOptionsPaypalPreferredLocale::PtPt => "pt-PT",
CreateCheckoutSessionPaymentMethodOptionsPaypalPreferredLocale::SkSk => "sk-SK",
CreateCheckoutSessionPaymentMethodOptionsPaypalPreferredLocale::SvSe => "sv-SE",
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsPaypalPreferredLocale {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionPaymentMethodOptionsPaypalPreferredLocale {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionPaymentMethodOptionsPaypalPreferredLocale {
fn default() -> Self {
Self::CsCz
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsPaypalSetupFutureUsage {
None,
OffSession,
}
impl CreateCheckoutSessionPaymentMethodOptionsPaypalSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsPaypalSetupFutureUsage::None => "none",
CreateCheckoutSessionPaymentMethodOptionsPaypalSetupFutureUsage::OffSession => {
"off_session"
}
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsPaypalSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionPaymentMethodOptionsPaypalSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionPaymentMethodOptionsPaypalSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsRevolutPaySetupFutureUsage {
None,
OffSession,
}
impl CreateCheckoutSessionPaymentMethodOptionsRevolutPaySetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsRevolutPaySetupFutureUsage::None => "none",
CreateCheckoutSessionPaymentMethodOptionsRevolutPaySetupFutureUsage::OffSession => {
"off_session"
}
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsRevolutPaySetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionPaymentMethodOptionsRevolutPaySetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionPaymentMethodOptionsRevolutPaySetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsSepaDebitSetupFutureUsage {
None,
OffSession,
OnSession,
}
impl CreateCheckoutSessionPaymentMethodOptionsSepaDebitSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsSepaDebitSetupFutureUsage::None => "none",
CreateCheckoutSessionPaymentMethodOptionsSepaDebitSetupFutureUsage::OffSession => {
"off_session"
}
CreateCheckoutSessionPaymentMethodOptionsSepaDebitSetupFutureUsage::OnSession => {
"on_session"
}
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsSepaDebitSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionPaymentMethodOptionsSepaDebitSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionPaymentMethodOptionsSepaDebitSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsSofortSetupFutureUsage {
None,
}
impl CreateCheckoutSessionPaymentMethodOptionsSofortSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsSofortSetupFutureUsage::None => "none",
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsSofortSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionPaymentMethodOptionsSofortSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionPaymentMethodOptionsSofortSetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsUsBankAccountFinancialConnectionsPermissions {
Balances,
Ownership,
PaymentMethod,
Transactions,
}
impl CreateCheckoutSessionPaymentMethodOptionsUsBankAccountFinancialConnectionsPermissions {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsUsBankAccountFinancialConnectionsPermissions::Balances => "balances",
CreateCheckoutSessionPaymentMethodOptionsUsBankAccountFinancialConnectionsPermissions::Ownership => "ownership",
CreateCheckoutSessionPaymentMethodOptionsUsBankAccountFinancialConnectionsPermissions::PaymentMethod => "payment_method",
CreateCheckoutSessionPaymentMethodOptionsUsBankAccountFinancialConnectionsPermissions::Transactions => "transactions",
}
}
}
impl AsRef<str>
for CreateCheckoutSessionPaymentMethodOptionsUsBankAccountFinancialConnectionsPermissions
{
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display
for CreateCheckoutSessionPaymentMethodOptionsUsBankAccountFinancialConnectionsPermissions
{
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CreateCheckoutSessionPaymentMethodOptionsUsBankAccountFinancialConnectionsPermissions
{
fn default() -> Self {
Self::Balances
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsUsBankAccountFinancialConnectionsPrefetch {
Balances,
Transactions,
}
impl CreateCheckoutSessionPaymentMethodOptionsUsBankAccountFinancialConnectionsPrefetch {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsUsBankAccountFinancialConnectionsPrefetch::Balances => "balances",
CreateCheckoutSessionPaymentMethodOptionsUsBankAccountFinancialConnectionsPrefetch::Transactions => "transactions",
}
}
}
impl AsRef<str>
for CreateCheckoutSessionPaymentMethodOptionsUsBankAccountFinancialConnectionsPrefetch
{
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display
for CreateCheckoutSessionPaymentMethodOptionsUsBankAccountFinancialConnectionsPrefetch
{
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CreateCheckoutSessionPaymentMethodOptionsUsBankAccountFinancialConnectionsPrefetch
{
fn default() -> Self {
Self::Balances
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsUsBankAccountSetupFutureUsage {
None,
OffSession,
OnSession,
}
impl CreateCheckoutSessionPaymentMethodOptionsUsBankAccountSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsUsBankAccountSetupFutureUsage::None => "none",
CreateCheckoutSessionPaymentMethodOptionsUsBankAccountSetupFutureUsage::OffSession => {
"off_session"
}
CreateCheckoutSessionPaymentMethodOptionsUsBankAccountSetupFutureUsage::OnSession => {
"on_session"
}
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsUsBankAccountSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionPaymentMethodOptionsUsBankAccountSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CreateCheckoutSessionPaymentMethodOptionsUsBankAccountSetupFutureUsage
{
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsUsBankAccountVerificationMethod {
Automatic,
Instant,
}
impl CreateCheckoutSessionPaymentMethodOptionsUsBankAccountVerificationMethod {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsUsBankAccountVerificationMethod::Automatic => {
"automatic"
}
CreateCheckoutSessionPaymentMethodOptionsUsBankAccountVerificationMethod::Instant => {
"instant"
}
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsUsBankAccountVerificationMethod {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display
for CreateCheckoutSessionPaymentMethodOptionsUsBankAccountVerificationMethod
{
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CreateCheckoutSessionPaymentMethodOptionsUsBankAccountVerificationMethod
{
fn default() -> Self {
Self::Automatic
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsWechatPayClient {
Android,
Ios,
Web,
}
impl CreateCheckoutSessionPaymentMethodOptionsWechatPayClient {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsWechatPayClient::Android => "android",
CreateCheckoutSessionPaymentMethodOptionsWechatPayClient::Ios => "ios",
CreateCheckoutSessionPaymentMethodOptionsWechatPayClient::Web => "web",
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsWechatPayClient {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionPaymentMethodOptionsWechatPayClient {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionPaymentMethodOptionsWechatPayClient {
fn default() -> Self {
Self::Android
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodOptionsWechatPaySetupFutureUsage {
None,
}
impl CreateCheckoutSessionPaymentMethodOptionsWechatPaySetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodOptionsWechatPaySetupFutureUsage::None => "none",
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodOptionsWechatPaySetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionPaymentMethodOptionsWechatPaySetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionPaymentMethodOptionsWechatPaySetupFutureUsage {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionPaymentMethodTypes {
AcssDebit,
Affirm,
AfterpayClearpay,
Alipay,
AuBecsDebit,
BacsDebit,
Bancontact,
Blik,
Boleto,
Card,
Cashapp,
CustomerBalance,
Eps,
Fpx,
Giropay,
Grabpay,
Ideal,
Klarna,
Konbini,
Link,
Oxxo,
P24,
Paynow,
Paypal,
Pix,
Promptpay,
RevolutPay,
SepaDebit,
Sofort,
Swish,
UsBankAccount,
WechatPay,
Zip,
}
impl CreateCheckoutSessionPaymentMethodTypes {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionPaymentMethodTypes::AcssDebit => "acss_debit",
CreateCheckoutSessionPaymentMethodTypes::Affirm => "affirm",
CreateCheckoutSessionPaymentMethodTypes::AfterpayClearpay => "afterpay_clearpay",
CreateCheckoutSessionPaymentMethodTypes::Alipay => "alipay",
CreateCheckoutSessionPaymentMethodTypes::AuBecsDebit => "au_becs_debit",
CreateCheckoutSessionPaymentMethodTypes::BacsDebit => "bacs_debit",
CreateCheckoutSessionPaymentMethodTypes::Bancontact => "bancontact",
CreateCheckoutSessionPaymentMethodTypes::Blik => "blik",
CreateCheckoutSessionPaymentMethodTypes::Boleto => "boleto",
CreateCheckoutSessionPaymentMethodTypes::Card => "card",
CreateCheckoutSessionPaymentMethodTypes::Cashapp => "cashapp",
CreateCheckoutSessionPaymentMethodTypes::CustomerBalance => "customer_balance",
CreateCheckoutSessionPaymentMethodTypes::Eps => "eps",
CreateCheckoutSessionPaymentMethodTypes::Fpx => "fpx",
CreateCheckoutSessionPaymentMethodTypes::Giropay => "giropay",
CreateCheckoutSessionPaymentMethodTypes::Grabpay => "grabpay",
CreateCheckoutSessionPaymentMethodTypes::Ideal => "ideal",
CreateCheckoutSessionPaymentMethodTypes::Klarna => "klarna",
CreateCheckoutSessionPaymentMethodTypes::Konbini => "konbini",
CreateCheckoutSessionPaymentMethodTypes::Link => "link",
CreateCheckoutSessionPaymentMethodTypes::Oxxo => "oxxo",
CreateCheckoutSessionPaymentMethodTypes::P24 => "p24",
CreateCheckoutSessionPaymentMethodTypes::Paynow => "paynow",
CreateCheckoutSessionPaymentMethodTypes::Paypal => "paypal",
CreateCheckoutSessionPaymentMethodTypes::Pix => "pix",
CreateCheckoutSessionPaymentMethodTypes::Promptpay => "promptpay",
CreateCheckoutSessionPaymentMethodTypes::RevolutPay => "revolut_pay",
CreateCheckoutSessionPaymentMethodTypes::SepaDebit => "sepa_debit",
CreateCheckoutSessionPaymentMethodTypes::Sofort => "sofort",
CreateCheckoutSessionPaymentMethodTypes::Swish => "swish",
CreateCheckoutSessionPaymentMethodTypes::UsBankAccount => "us_bank_account",
CreateCheckoutSessionPaymentMethodTypes::WechatPay => "wechat_pay",
CreateCheckoutSessionPaymentMethodTypes::Zip => "zip",
}
}
}
impl AsRef<str> for CreateCheckoutSessionPaymentMethodTypes {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionPaymentMethodTypes {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionPaymentMethodTypes {
fn default() -> Self {
Self::AcssDebit
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionShippingAddressCollectionAllowedCountries {
#[serde(rename = "AC")]
Ac,
#[serde(rename = "AD")]
Ad,
#[serde(rename = "AE")]
Ae,
#[serde(rename = "AF")]
Af,
#[serde(rename = "AG")]
Ag,
#[serde(rename = "AI")]
Ai,
#[serde(rename = "AL")]
Al,
#[serde(rename = "AM")]
Am,
#[serde(rename = "AO")]
Ao,
#[serde(rename = "AQ")]
Aq,
#[serde(rename = "AR")]
Ar,
#[serde(rename = "AT")]
At,
#[serde(rename = "AU")]
Au,
#[serde(rename = "AW")]
Aw,
#[serde(rename = "AX")]
Ax,
#[serde(rename = "AZ")]
Az,
#[serde(rename = "BA")]
Ba,
#[serde(rename = "BB")]
Bb,
#[serde(rename = "BD")]
Bd,
#[serde(rename = "BE")]
Be,
#[serde(rename = "BF")]
Bf,
#[serde(rename = "BG")]
Bg,
#[serde(rename = "BH")]
Bh,
#[serde(rename = "BI")]
Bi,
#[serde(rename = "BJ")]
Bj,
#[serde(rename = "BL")]
Bl,
#[serde(rename = "BM")]
Bm,
#[serde(rename = "BN")]
Bn,
#[serde(rename = "BO")]
Bo,
#[serde(rename = "BQ")]
Bq,
#[serde(rename = "BR")]
Br,
#[serde(rename = "BS")]
Bs,
#[serde(rename = "BT")]
Bt,
#[serde(rename = "BV")]
Bv,
#[serde(rename = "BW")]
Bw,
#[serde(rename = "BY")]
By,
#[serde(rename = "BZ")]
Bz,
#[serde(rename = "CA")]
Ca,
#[serde(rename = "CD")]
Cd,
#[serde(rename = "CF")]
Cf,
#[serde(rename = "CG")]
Cg,
#[serde(rename = "CH")]
Ch,
#[serde(rename = "CI")]
Ci,
#[serde(rename = "CK")]
Ck,
#[serde(rename = "CL")]
Cl,
#[serde(rename = "CM")]
Cm,
#[serde(rename = "CN")]
Cn,
#[serde(rename = "CO")]
Co,
#[serde(rename = "CR")]
Cr,
#[serde(rename = "CV")]
Cv,
#[serde(rename = "CW")]
Cw,
#[serde(rename = "CY")]
Cy,
#[serde(rename = "CZ")]
Cz,
#[serde(rename = "DE")]
De,
#[serde(rename = "DJ")]
Dj,
#[serde(rename = "DK")]
Dk,
#[serde(rename = "DM")]
Dm,
#[serde(rename = "DO")]
Do,
#[serde(rename = "DZ")]
Dz,
#[serde(rename = "EC")]
Ec,
#[serde(rename = "EE")]
Ee,
#[serde(rename = "EG")]
Eg,
#[serde(rename = "EH")]
Eh,
#[serde(rename = "ER")]
Er,
#[serde(rename = "ES")]
Es,
#[serde(rename = "ET")]
Et,
#[serde(rename = "FI")]
Fi,
#[serde(rename = "FJ")]
Fj,
#[serde(rename = "FK")]
Fk,
#[serde(rename = "FO")]
Fo,
#[serde(rename = "FR")]
Fr,
#[serde(rename = "GA")]
Ga,
#[serde(rename = "GB")]
Gb,
#[serde(rename = "GD")]
Gd,
#[serde(rename = "GE")]
Ge,
#[serde(rename = "GF")]
Gf,
#[serde(rename = "GG")]
Gg,
#[serde(rename = "GH")]
Gh,
#[serde(rename = "GI")]
Gi,
#[serde(rename = "GL")]
Gl,
#[serde(rename = "GM")]
Gm,
#[serde(rename = "GN")]
Gn,
#[serde(rename = "GP")]
Gp,
#[serde(rename = "GQ")]
Gq,
#[serde(rename = "GR")]
Gr,
#[serde(rename = "GS")]
Gs,
#[serde(rename = "GT")]
Gt,
#[serde(rename = "GU")]
Gu,
#[serde(rename = "GW")]
Gw,
#[serde(rename = "GY")]
Gy,
#[serde(rename = "HK")]
Hk,
#[serde(rename = "HN")]
Hn,
#[serde(rename = "HR")]
Hr,
#[serde(rename = "HT")]
Ht,
#[serde(rename = "HU")]
Hu,
#[serde(rename = "ID")]
Id,
#[serde(rename = "IE")]
Ie,
#[serde(rename = "IL")]
Il,
#[serde(rename = "IM")]
Im,
#[serde(rename = "IN")]
In,
#[serde(rename = "IO")]
Io,
#[serde(rename = "IQ")]
Iq,
#[serde(rename = "IS")]
Is,
#[serde(rename = "IT")]
It,
#[serde(rename = "JE")]
Je,
#[serde(rename = "JM")]
Jm,
#[serde(rename = "JO")]
Jo,
#[serde(rename = "JP")]
Jp,
#[serde(rename = "KE")]
Ke,
#[serde(rename = "KG")]
Kg,
#[serde(rename = "KH")]
Kh,
#[serde(rename = "KI")]
Ki,
#[serde(rename = "KM")]
Km,
#[serde(rename = "KN")]
Kn,
#[serde(rename = "KR")]
Kr,
#[serde(rename = "KW")]
Kw,
#[serde(rename = "KY")]
Ky,
#[serde(rename = "KZ")]
Kz,
#[serde(rename = "LA")]
La,
#[serde(rename = "LB")]
Lb,
#[serde(rename = "LC")]
Lc,
#[serde(rename = "LI")]
Li,
#[serde(rename = "LK")]
Lk,
#[serde(rename = "LR")]
Lr,
#[serde(rename = "LS")]
Ls,
#[serde(rename = "LT")]
Lt,
#[serde(rename = "LU")]
Lu,
#[serde(rename = "LV")]
Lv,
#[serde(rename = "LY")]
Ly,
#[serde(rename = "MA")]
Ma,
#[serde(rename = "MC")]
Mc,
#[serde(rename = "MD")]
Md,
#[serde(rename = "ME")]
Me,
#[serde(rename = "MF")]
Mf,
#[serde(rename = "MG")]
Mg,
#[serde(rename = "MK")]
Mk,
#[serde(rename = "ML")]
Ml,
#[serde(rename = "MM")]
Mm,
#[serde(rename = "MN")]
Mn,
#[serde(rename = "MO")]
Mo,
#[serde(rename = "MQ")]
Mq,
#[serde(rename = "MR")]
Mr,
#[serde(rename = "MS")]
Ms,
#[serde(rename = "MT")]
Mt,
#[serde(rename = "MU")]
Mu,
#[serde(rename = "MV")]
Mv,
#[serde(rename = "MW")]
Mw,
#[serde(rename = "MX")]
Mx,
#[serde(rename = "MY")]
My,
#[serde(rename = "MZ")]
Mz,
#[serde(rename = "NA")]
Na,
#[serde(rename = "NC")]
Nc,
#[serde(rename = "NE")]
Ne,
#[serde(rename = "NG")]
Ng,
#[serde(rename = "NI")]
Ni,
#[serde(rename = "NL")]
Nl,
#[serde(rename = "NO")]
No,
#[serde(rename = "NP")]
Np,
#[serde(rename = "NR")]
Nr,
#[serde(rename = "NU")]
Nu,
#[serde(rename = "NZ")]
Nz,
#[serde(rename = "OM")]
Om,
#[serde(rename = "PA")]
Pa,
#[serde(rename = "PE")]
Pe,
#[serde(rename = "PF")]
Pf,
#[serde(rename = "PG")]
Pg,
#[serde(rename = "PH")]
Ph,
#[serde(rename = "PK")]
Pk,
#[serde(rename = "PL")]
Pl,
#[serde(rename = "PM")]
Pm,
#[serde(rename = "PN")]
Pn,
#[serde(rename = "PR")]
Pr,
#[serde(rename = "PS")]
Ps,
#[serde(rename = "PT")]
Pt,
#[serde(rename = "PY")]
Py,
#[serde(rename = "QA")]
Qa,
#[serde(rename = "RE")]
Re,
#[serde(rename = "RO")]
Ro,
#[serde(rename = "RS")]
Rs,
#[serde(rename = "RU")]
Ru,
#[serde(rename = "RW")]
Rw,
#[serde(rename = "SA")]
Sa,
#[serde(rename = "SB")]
Sb,
#[serde(rename = "SC")]
Sc,
#[serde(rename = "SE")]
Se,
#[serde(rename = "SG")]
Sg,
#[serde(rename = "SH")]
Sh,
#[serde(rename = "SI")]
Si,
#[serde(rename = "SJ")]
Sj,
#[serde(rename = "SK")]
Sk,
#[serde(rename = "SL")]
Sl,
#[serde(rename = "SM")]
Sm,
#[serde(rename = "SN")]
Sn,
#[serde(rename = "SO")]
So,
#[serde(rename = "SR")]
Sr,
#[serde(rename = "SS")]
Ss,
#[serde(rename = "ST")]
St,
#[serde(rename = "SV")]
Sv,
#[serde(rename = "SX")]
Sx,
#[serde(rename = "SZ")]
Sz,
#[serde(rename = "TA")]
Ta,
#[serde(rename = "TC")]
Tc,
#[serde(rename = "TD")]
Td,
#[serde(rename = "TF")]
Tf,
#[serde(rename = "TG")]
Tg,
#[serde(rename = "TH")]
Th,
#[serde(rename = "TJ")]
Tj,
#[serde(rename = "TK")]
Tk,
#[serde(rename = "TL")]
Tl,
#[serde(rename = "TM")]
Tm,
#[serde(rename = "TN")]
Tn,
#[serde(rename = "TO")]
To,
#[serde(rename = "TR")]
Tr,
#[serde(rename = "TT")]
Tt,
#[serde(rename = "TV")]
Tv,
#[serde(rename = "TW")]
Tw,
#[serde(rename = "TZ")]
Tz,
#[serde(rename = "UA")]
Ua,
#[serde(rename = "UG")]
Ug,
#[serde(rename = "US")]
Us,
#[serde(rename = "UY")]
Uy,
#[serde(rename = "UZ")]
Uz,
#[serde(rename = "VA")]
Va,
#[serde(rename = "VC")]
Vc,
#[serde(rename = "VE")]
Ve,
#[serde(rename = "VG")]
Vg,
#[serde(rename = "VN")]
Vn,
#[serde(rename = "VU")]
Vu,
#[serde(rename = "WF")]
Wf,
#[serde(rename = "WS")]
Ws,
#[serde(rename = "XK")]
Xk,
#[serde(rename = "YE")]
Ye,
#[serde(rename = "YT")]
Yt,
#[serde(rename = "ZA")]
Za,
#[serde(rename = "ZM")]
Zm,
#[serde(rename = "ZW")]
Zw,
#[serde(rename = "ZZ")]
Zz,
}
impl CreateCheckoutSessionShippingAddressCollectionAllowedCountries {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ac => "AC",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ad => "AD",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ae => "AE",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Af => "AF",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ag => "AG",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ai => "AI",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Al => "AL",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Am => "AM",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ao => "AO",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Aq => "AQ",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ar => "AR",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::At => "AT",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Au => "AU",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Aw => "AW",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ax => "AX",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Az => "AZ",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ba => "BA",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Bb => "BB",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Bd => "BD",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Be => "BE",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Bf => "BF",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Bg => "BG",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Bh => "BH",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Bi => "BI",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Bj => "BJ",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Bl => "BL",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Bm => "BM",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Bn => "BN",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Bo => "BO",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Bq => "BQ",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Br => "BR",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Bs => "BS",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Bt => "BT",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Bv => "BV",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Bw => "BW",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::By => "BY",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Bz => "BZ",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ca => "CA",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Cd => "CD",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Cf => "CF",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Cg => "CG",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ch => "CH",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ci => "CI",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ck => "CK",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Cl => "CL",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Cm => "CM",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Cn => "CN",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Co => "CO",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Cr => "CR",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Cv => "CV",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Cw => "CW",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Cy => "CY",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Cz => "CZ",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::De => "DE",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Dj => "DJ",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Dk => "DK",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Dm => "DM",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Do => "DO",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Dz => "DZ",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ec => "EC",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ee => "EE",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Eg => "EG",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Eh => "EH",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Er => "ER",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Es => "ES",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Et => "ET",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Fi => "FI",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Fj => "FJ",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Fk => "FK",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Fo => "FO",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Fr => "FR",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ga => "GA",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Gb => "GB",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Gd => "GD",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ge => "GE",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Gf => "GF",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Gg => "GG",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Gh => "GH",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Gi => "GI",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Gl => "GL",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Gm => "GM",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Gn => "GN",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Gp => "GP",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Gq => "GQ",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Gr => "GR",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Gs => "GS",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Gt => "GT",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Gu => "GU",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Gw => "GW",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Gy => "GY",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Hk => "HK",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Hn => "HN",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Hr => "HR",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ht => "HT",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Hu => "HU",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Id => "ID",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ie => "IE",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Il => "IL",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Im => "IM",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::In => "IN",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Io => "IO",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Iq => "IQ",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Is => "IS",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::It => "IT",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Je => "JE",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Jm => "JM",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Jo => "JO",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Jp => "JP",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ke => "KE",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Kg => "KG",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Kh => "KH",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ki => "KI",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Km => "KM",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Kn => "KN",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Kr => "KR",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Kw => "KW",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ky => "KY",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Kz => "KZ",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::La => "LA",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Lb => "LB",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Lc => "LC",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Li => "LI",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Lk => "LK",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Lr => "LR",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ls => "LS",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Lt => "LT",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Lu => "LU",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Lv => "LV",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ly => "LY",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ma => "MA",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Mc => "MC",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Md => "MD",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Me => "ME",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Mf => "MF",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Mg => "MG",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Mk => "MK",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ml => "ML",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Mm => "MM",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Mn => "MN",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Mo => "MO",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Mq => "MQ",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Mr => "MR",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ms => "MS",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Mt => "MT",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Mu => "MU",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Mv => "MV",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Mw => "MW",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Mx => "MX",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::My => "MY",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Mz => "MZ",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Na => "NA",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Nc => "NC",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ne => "NE",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ng => "NG",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ni => "NI",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Nl => "NL",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::No => "NO",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Np => "NP",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Nr => "NR",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Nu => "NU",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Nz => "NZ",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Om => "OM",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Pa => "PA",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Pe => "PE",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Pf => "PF",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Pg => "PG",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ph => "PH",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Pk => "PK",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Pl => "PL",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Pm => "PM",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Pn => "PN",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Pr => "PR",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ps => "PS",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Pt => "PT",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Py => "PY",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Qa => "QA",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Re => "RE",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ro => "RO",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Rs => "RS",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ru => "RU",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Rw => "RW",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Sa => "SA",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Sb => "SB",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Sc => "SC",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Se => "SE",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Sg => "SG",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Sh => "SH",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Si => "SI",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Sj => "SJ",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Sk => "SK",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Sl => "SL",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Sm => "SM",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Sn => "SN",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::So => "SO",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Sr => "SR",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ss => "SS",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::St => "ST",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Sv => "SV",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Sx => "SX",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Sz => "SZ",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ta => "TA",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Tc => "TC",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Td => "TD",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Tf => "TF",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Tg => "TG",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Th => "TH",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Tj => "TJ",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Tk => "TK",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Tl => "TL",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Tm => "TM",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Tn => "TN",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::To => "TO",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Tr => "TR",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Tt => "TT",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Tv => "TV",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Tw => "TW",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Tz => "TZ",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ua => "UA",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ug => "UG",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Us => "US",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Uy => "UY",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Uz => "UZ",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Va => "VA",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Vc => "VC",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ve => "VE",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Vg => "VG",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Vn => "VN",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Vu => "VU",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Wf => "WF",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ws => "WS",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Xk => "XK",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Ye => "YE",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Yt => "YT",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Za => "ZA",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Zm => "ZM",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Zw => "ZW",
CreateCheckoutSessionShippingAddressCollectionAllowedCountries::Zz => "ZZ",
}
}
}
impl AsRef<str> for CreateCheckoutSessionShippingAddressCollectionAllowedCountries {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionShippingAddressCollectionAllowedCountries {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionShippingAddressCollectionAllowedCountries {
fn default() -> Self {
Self::Ac
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionShippingOptionsShippingRateDataDeliveryEstimateMaximumUnit {
BusinessDay,
Day,
Hour,
Month,
Week,
}
impl CreateCheckoutSessionShippingOptionsShippingRateDataDeliveryEstimateMaximumUnit {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionShippingOptionsShippingRateDataDeliveryEstimateMaximumUnit::BusinessDay => "business_day",
CreateCheckoutSessionShippingOptionsShippingRateDataDeliveryEstimateMaximumUnit::Day => "day",
CreateCheckoutSessionShippingOptionsShippingRateDataDeliveryEstimateMaximumUnit::Hour => "hour",
CreateCheckoutSessionShippingOptionsShippingRateDataDeliveryEstimateMaximumUnit::Month => "month",
CreateCheckoutSessionShippingOptionsShippingRateDataDeliveryEstimateMaximumUnit::Week => "week",
}
}
}
impl AsRef<str>
for CreateCheckoutSessionShippingOptionsShippingRateDataDeliveryEstimateMaximumUnit
{
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display
for CreateCheckoutSessionShippingOptionsShippingRateDataDeliveryEstimateMaximumUnit
{
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CreateCheckoutSessionShippingOptionsShippingRateDataDeliveryEstimateMaximumUnit
{
fn default() -> Self {
Self::BusinessDay
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionShippingOptionsShippingRateDataDeliveryEstimateMinimumUnit {
BusinessDay,
Day,
Hour,
Month,
Week,
}
impl CreateCheckoutSessionShippingOptionsShippingRateDataDeliveryEstimateMinimumUnit {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionShippingOptionsShippingRateDataDeliveryEstimateMinimumUnit::BusinessDay => "business_day",
CreateCheckoutSessionShippingOptionsShippingRateDataDeliveryEstimateMinimumUnit::Day => "day",
CreateCheckoutSessionShippingOptionsShippingRateDataDeliveryEstimateMinimumUnit::Hour => "hour",
CreateCheckoutSessionShippingOptionsShippingRateDataDeliveryEstimateMinimumUnit::Month => "month",
CreateCheckoutSessionShippingOptionsShippingRateDataDeliveryEstimateMinimumUnit::Week => "week",
}
}
}
impl AsRef<str>
for CreateCheckoutSessionShippingOptionsShippingRateDataDeliveryEstimateMinimumUnit
{
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display
for CreateCheckoutSessionShippingOptionsShippingRateDataDeliveryEstimateMinimumUnit
{
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CreateCheckoutSessionShippingOptionsShippingRateDataDeliveryEstimateMinimumUnit
{
fn default() -> Self {
Self::BusinessDay
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionShippingOptionsShippingRateDataFixedAmountCurrencyOptionsTaxBehavior {
Exclusive,
Inclusive,
Unspecified,
}
impl CreateCheckoutSessionShippingOptionsShippingRateDataFixedAmountCurrencyOptionsTaxBehavior {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionShippingOptionsShippingRateDataFixedAmountCurrencyOptionsTaxBehavior::Exclusive => "exclusive",
CreateCheckoutSessionShippingOptionsShippingRateDataFixedAmountCurrencyOptionsTaxBehavior::Inclusive => "inclusive",
CreateCheckoutSessionShippingOptionsShippingRateDataFixedAmountCurrencyOptionsTaxBehavior::Unspecified => "unspecified",
}
}
}
impl AsRef<str>
for CreateCheckoutSessionShippingOptionsShippingRateDataFixedAmountCurrencyOptionsTaxBehavior
{
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display
for CreateCheckoutSessionShippingOptionsShippingRateDataFixedAmountCurrencyOptionsTaxBehavior
{
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CreateCheckoutSessionShippingOptionsShippingRateDataFixedAmountCurrencyOptionsTaxBehavior
{
fn default() -> Self {
Self::Exclusive
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionShippingOptionsShippingRateDataTaxBehavior {
Exclusive,
Inclusive,
Unspecified,
}
impl CreateCheckoutSessionShippingOptionsShippingRateDataTaxBehavior {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionShippingOptionsShippingRateDataTaxBehavior::Exclusive => {
"exclusive"
}
CreateCheckoutSessionShippingOptionsShippingRateDataTaxBehavior::Inclusive => {
"inclusive"
}
CreateCheckoutSessionShippingOptionsShippingRateDataTaxBehavior::Unspecified => {
"unspecified"
}
}
}
}
impl AsRef<str> for CreateCheckoutSessionShippingOptionsShippingRateDataTaxBehavior {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionShippingOptionsShippingRateDataTaxBehavior {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionShippingOptionsShippingRateDataTaxBehavior {
fn default() -> Self {
Self::Exclusive
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionShippingOptionsShippingRateDataType {
FixedAmount,
}
impl CreateCheckoutSessionShippingOptionsShippingRateDataType {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionShippingOptionsShippingRateDataType::FixedAmount => "fixed_amount",
}
}
}
impl AsRef<str> for CreateCheckoutSessionShippingOptionsShippingRateDataType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionShippingOptionsShippingRateDataType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionShippingOptionsShippingRateDataType {
fn default() -> Self {
Self::FixedAmount
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionSubscriptionDataInvoiceSettingsIssuerType {
Account,
#[serde(rename = "self")]
Self_,
}
impl CreateCheckoutSessionSubscriptionDataInvoiceSettingsIssuerType {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionSubscriptionDataInvoiceSettingsIssuerType::Account => "account",
CreateCheckoutSessionSubscriptionDataInvoiceSettingsIssuerType::Self_ => "self",
}
}
}
impl AsRef<str> for CreateCheckoutSessionSubscriptionDataInvoiceSettingsIssuerType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionSubscriptionDataInvoiceSettingsIssuerType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionSubscriptionDataInvoiceSettingsIssuerType {
fn default() -> Self {
Self::Account
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionSubscriptionDataProrationBehavior {
CreateProrations,
None,
}
impl CreateCheckoutSessionSubscriptionDataProrationBehavior {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionSubscriptionDataProrationBehavior::CreateProrations => {
"create_prorations"
}
CreateCheckoutSessionSubscriptionDataProrationBehavior::None => "none",
}
}
}
impl AsRef<str> for CreateCheckoutSessionSubscriptionDataProrationBehavior {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateCheckoutSessionSubscriptionDataProrationBehavior {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateCheckoutSessionSubscriptionDataProrationBehavior {
fn default() -> Self {
Self::CreateProrations
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateCheckoutSessionSubscriptionDataTrialSettingsEndBehaviorMissingPaymentMethod {
Cancel,
CreateInvoice,
Pause,
}
impl CreateCheckoutSessionSubscriptionDataTrialSettingsEndBehaviorMissingPaymentMethod {
pub fn as_str(self) -> &'static str {
match self {
CreateCheckoutSessionSubscriptionDataTrialSettingsEndBehaviorMissingPaymentMethod::Cancel => "cancel",
CreateCheckoutSessionSubscriptionDataTrialSettingsEndBehaviorMissingPaymentMethod::CreateInvoice => "create_invoice",
CreateCheckoutSessionSubscriptionDataTrialSettingsEndBehaviorMissingPaymentMethod::Pause => "pause",
}
}
}
impl AsRef<str>
for CreateCheckoutSessionSubscriptionDataTrialSettingsEndBehaviorMissingPaymentMethod
{
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display
for CreateCheckoutSessionSubscriptionDataTrialSettingsEndBehaviorMissingPaymentMethod
{
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CreateCheckoutSessionSubscriptionDataTrialSettingsEndBehaviorMissingPaymentMethod
{
fn default() -> Self {
Self::Cancel
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum LineItemsTaxAmountTaxabilityReason {
CustomerExempt,
NotCollecting,
NotSubjectToTax,
NotSupported,
PortionProductExempt,
PortionReducedRated,
PortionStandardRated,
ProductExempt,
ProductExemptHoliday,
ProportionallyRated,
ReducedRated,
ReverseCharge,
StandardRated,
TaxableBasisReduced,
ZeroRated,
}
impl LineItemsTaxAmountTaxabilityReason {
pub fn as_str(self) -> &'static str {
match self {
LineItemsTaxAmountTaxabilityReason::CustomerExempt => "customer_exempt",
LineItemsTaxAmountTaxabilityReason::NotCollecting => "not_collecting",
LineItemsTaxAmountTaxabilityReason::NotSubjectToTax => "not_subject_to_tax",
LineItemsTaxAmountTaxabilityReason::NotSupported => "not_supported",
LineItemsTaxAmountTaxabilityReason::PortionProductExempt => "portion_product_exempt",
LineItemsTaxAmountTaxabilityReason::PortionReducedRated => "portion_reduced_rated",
LineItemsTaxAmountTaxabilityReason::PortionStandardRated => "portion_standard_rated",
LineItemsTaxAmountTaxabilityReason::ProductExempt => "product_exempt",
LineItemsTaxAmountTaxabilityReason::ProductExemptHoliday => "product_exempt_holiday",
LineItemsTaxAmountTaxabilityReason::ProportionallyRated => "proportionally_rated",
LineItemsTaxAmountTaxabilityReason::ReducedRated => "reduced_rated",
LineItemsTaxAmountTaxabilityReason::ReverseCharge => "reverse_charge",
LineItemsTaxAmountTaxabilityReason::StandardRated => "standard_rated",
LineItemsTaxAmountTaxabilityReason::TaxableBasisReduced => "taxable_basis_reduced",
LineItemsTaxAmountTaxabilityReason::ZeroRated => "zero_rated",
}
}
}
impl AsRef<str> for LineItemsTaxAmountTaxabilityReason {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for LineItemsTaxAmountTaxabilityReason {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for LineItemsTaxAmountTaxabilityReason {
fn default() -> Self {
Self::CustomerExempt
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum PaymentPagesCheckoutSessionAutomaticTaxStatus {
Complete,
Failed,
RequiresLocationInputs,
}
impl PaymentPagesCheckoutSessionAutomaticTaxStatus {
pub fn as_str(self) -> &'static str {
match self {
PaymentPagesCheckoutSessionAutomaticTaxStatus::Complete => "complete",
PaymentPagesCheckoutSessionAutomaticTaxStatus::Failed => "failed",
PaymentPagesCheckoutSessionAutomaticTaxStatus::RequiresLocationInputs => {
"requires_location_inputs"
}
}
}
}
impl AsRef<str> for PaymentPagesCheckoutSessionAutomaticTaxStatus {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for PaymentPagesCheckoutSessionAutomaticTaxStatus {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for PaymentPagesCheckoutSessionAutomaticTaxStatus {
fn default() -> Self {
Self::Complete
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum PaymentPagesCheckoutSessionConsentCollectionPromotions {
Auto,
None,
}
impl PaymentPagesCheckoutSessionConsentCollectionPromotions {
pub fn as_str(self) -> &'static str {
match self {
PaymentPagesCheckoutSessionConsentCollectionPromotions::Auto => "auto",
PaymentPagesCheckoutSessionConsentCollectionPromotions::None => "none",
}
}
}
impl AsRef<str> for PaymentPagesCheckoutSessionConsentCollectionPromotions {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for PaymentPagesCheckoutSessionConsentCollectionPromotions {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for PaymentPagesCheckoutSessionConsentCollectionPromotions {
fn default() -> Self {
Self::Auto
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum PaymentPagesCheckoutSessionConsentCollectionTermsOfService {
None,
Required,
}
impl PaymentPagesCheckoutSessionConsentCollectionTermsOfService {
pub fn as_str(self) -> &'static str {
match self {
PaymentPagesCheckoutSessionConsentCollectionTermsOfService::None => "none",
PaymentPagesCheckoutSessionConsentCollectionTermsOfService::Required => "required",
}
}
}
impl AsRef<str> for PaymentPagesCheckoutSessionConsentCollectionTermsOfService {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for PaymentPagesCheckoutSessionConsentCollectionTermsOfService {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for PaymentPagesCheckoutSessionConsentCollectionTermsOfService {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum PaymentPagesCheckoutSessionConsentPromotions {
OptIn,
OptOut,
}
impl PaymentPagesCheckoutSessionConsentPromotions {
pub fn as_str(self) -> &'static str {
match self {
PaymentPagesCheckoutSessionConsentPromotions::OptIn => "opt_in",
PaymentPagesCheckoutSessionConsentPromotions::OptOut => "opt_out",
}
}
}
impl AsRef<str> for PaymentPagesCheckoutSessionConsentPromotions {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for PaymentPagesCheckoutSessionConsentPromotions {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for PaymentPagesCheckoutSessionConsentPromotions {
fn default() -> Self {
Self::OptIn
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum PaymentPagesCheckoutSessionConsentTermsOfService {
Accepted,
}
impl PaymentPagesCheckoutSessionConsentTermsOfService {
pub fn as_str(self) -> &'static str {
match self {
PaymentPagesCheckoutSessionConsentTermsOfService::Accepted => "accepted",
}
}
}
impl AsRef<str> for PaymentPagesCheckoutSessionConsentTermsOfService {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for PaymentPagesCheckoutSessionConsentTermsOfService {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for PaymentPagesCheckoutSessionConsentTermsOfService {
fn default() -> Self {
Self::Accepted
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum PaymentPagesCheckoutSessionCustomFieldsLabelType {
Custom,
}
impl PaymentPagesCheckoutSessionCustomFieldsLabelType {
pub fn as_str(self) -> &'static str {
match self {
PaymentPagesCheckoutSessionCustomFieldsLabelType::Custom => "custom",
}
}
}
impl AsRef<str> for PaymentPagesCheckoutSessionCustomFieldsLabelType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for PaymentPagesCheckoutSessionCustomFieldsLabelType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for PaymentPagesCheckoutSessionCustomFieldsLabelType {
fn default() -> Self {
Self::Custom
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum PaymentPagesCheckoutSessionCustomFieldsType {
Dropdown,
Numeric,
Text,
}
impl PaymentPagesCheckoutSessionCustomFieldsType {
pub fn as_str(self) -> &'static str {
match self {
PaymentPagesCheckoutSessionCustomFieldsType::Dropdown => "dropdown",
PaymentPagesCheckoutSessionCustomFieldsType::Numeric => "numeric",
PaymentPagesCheckoutSessionCustomFieldsType::Text => "text",
}
}
}
impl AsRef<str> for PaymentPagesCheckoutSessionCustomFieldsType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for PaymentPagesCheckoutSessionCustomFieldsType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for PaymentPagesCheckoutSessionCustomFieldsType {
fn default() -> Self {
Self::Dropdown
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum PaymentPagesCheckoutSessionCustomerDetailsTaxExempt {
Exempt,
None,
Reverse,
}
impl PaymentPagesCheckoutSessionCustomerDetailsTaxExempt {
pub fn as_str(self) -> &'static str {
match self {
PaymentPagesCheckoutSessionCustomerDetailsTaxExempt::Exempt => "exempt",
PaymentPagesCheckoutSessionCustomerDetailsTaxExempt::None => "none",
PaymentPagesCheckoutSessionCustomerDetailsTaxExempt::Reverse => "reverse",
}
}
}
impl AsRef<str> for PaymentPagesCheckoutSessionCustomerDetailsTaxExempt {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for PaymentPagesCheckoutSessionCustomerDetailsTaxExempt {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for PaymentPagesCheckoutSessionCustomerDetailsTaxExempt {
fn default() -> Self {
Self::Exempt
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum PaymentPagesCheckoutSessionPaymentMethodReuseAgreementPosition {
Auto,
Hidden,
}
impl PaymentPagesCheckoutSessionPaymentMethodReuseAgreementPosition {
pub fn as_str(self) -> &'static str {
match self {
PaymentPagesCheckoutSessionPaymentMethodReuseAgreementPosition::Auto => "auto",
PaymentPagesCheckoutSessionPaymentMethodReuseAgreementPosition::Hidden => "hidden",
}
}
}
impl AsRef<str> for PaymentPagesCheckoutSessionPaymentMethodReuseAgreementPosition {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for PaymentPagesCheckoutSessionPaymentMethodReuseAgreementPosition {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for PaymentPagesCheckoutSessionPaymentMethodReuseAgreementPosition {
fn default() -> Self {
Self::Auto
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries {
#[serde(rename = "AC")]
Ac,
#[serde(rename = "AD")]
Ad,
#[serde(rename = "AE")]
Ae,
#[serde(rename = "AF")]
Af,
#[serde(rename = "AG")]
Ag,
#[serde(rename = "AI")]
Ai,
#[serde(rename = "AL")]
Al,
#[serde(rename = "AM")]
Am,
#[serde(rename = "AO")]
Ao,
#[serde(rename = "AQ")]
Aq,
#[serde(rename = "AR")]
Ar,
#[serde(rename = "AT")]
At,
#[serde(rename = "AU")]
Au,
#[serde(rename = "AW")]
Aw,
#[serde(rename = "AX")]
Ax,
#[serde(rename = "AZ")]
Az,
#[serde(rename = "BA")]
Ba,
#[serde(rename = "BB")]
Bb,
#[serde(rename = "BD")]
Bd,
#[serde(rename = "BE")]
Be,
#[serde(rename = "BF")]
Bf,
#[serde(rename = "BG")]
Bg,
#[serde(rename = "BH")]
Bh,
#[serde(rename = "BI")]
Bi,
#[serde(rename = "BJ")]
Bj,
#[serde(rename = "BL")]
Bl,
#[serde(rename = "BM")]
Bm,
#[serde(rename = "BN")]
Bn,
#[serde(rename = "BO")]
Bo,
#[serde(rename = "BQ")]
Bq,
#[serde(rename = "BR")]
Br,
#[serde(rename = "BS")]
Bs,
#[serde(rename = "BT")]
Bt,
#[serde(rename = "BV")]
Bv,
#[serde(rename = "BW")]
Bw,
#[serde(rename = "BY")]
By,
#[serde(rename = "BZ")]
Bz,
#[serde(rename = "CA")]
Ca,
#[serde(rename = "CD")]
Cd,
#[serde(rename = "CF")]
Cf,
#[serde(rename = "CG")]
Cg,
#[serde(rename = "CH")]
Ch,
#[serde(rename = "CI")]
Ci,
#[serde(rename = "CK")]
Ck,
#[serde(rename = "CL")]
Cl,
#[serde(rename = "CM")]
Cm,
#[serde(rename = "CN")]
Cn,
#[serde(rename = "CO")]
Co,
#[serde(rename = "CR")]
Cr,
#[serde(rename = "CV")]
Cv,
#[serde(rename = "CW")]
Cw,
#[serde(rename = "CY")]
Cy,
#[serde(rename = "CZ")]
Cz,
#[serde(rename = "DE")]
De,
#[serde(rename = "DJ")]
Dj,
#[serde(rename = "DK")]
Dk,
#[serde(rename = "DM")]
Dm,
#[serde(rename = "DO")]
Do,
#[serde(rename = "DZ")]
Dz,
#[serde(rename = "EC")]
Ec,
#[serde(rename = "EE")]
Ee,
#[serde(rename = "EG")]
Eg,
#[serde(rename = "EH")]
Eh,
#[serde(rename = "ER")]
Er,
#[serde(rename = "ES")]
Es,
#[serde(rename = "ET")]
Et,
#[serde(rename = "FI")]
Fi,
#[serde(rename = "FJ")]
Fj,
#[serde(rename = "FK")]
Fk,
#[serde(rename = "FO")]
Fo,
#[serde(rename = "FR")]
Fr,
#[serde(rename = "GA")]
Ga,
#[serde(rename = "GB")]
Gb,
#[serde(rename = "GD")]
Gd,
#[serde(rename = "GE")]
Ge,
#[serde(rename = "GF")]
Gf,
#[serde(rename = "GG")]
Gg,
#[serde(rename = "GH")]
Gh,
#[serde(rename = "GI")]
Gi,
#[serde(rename = "GL")]
Gl,
#[serde(rename = "GM")]
Gm,
#[serde(rename = "GN")]
Gn,
#[serde(rename = "GP")]
Gp,
#[serde(rename = "GQ")]
Gq,
#[serde(rename = "GR")]
Gr,
#[serde(rename = "GS")]
Gs,
#[serde(rename = "GT")]
Gt,
#[serde(rename = "GU")]
Gu,
#[serde(rename = "GW")]
Gw,
#[serde(rename = "GY")]
Gy,
#[serde(rename = "HK")]
Hk,
#[serde(rename = "HN")]
Hn,
#[serde(rename = "HR")]
Hr,
#[serde(rename = "HT")]
Ht,
#[serde(rename = "HU")]
Hu,
#[serde(rename = "ID")]
Id,
#[serde(rename = "IE")]
Ie,
#[serde(rename = "IL")]
Il,
#[serde(rename = "IM")]
Im,
#[serde(rename = "IN")]
In,
#[serde(rename = "IO")]
Io,
#[serde(rename = "IQ")]
Iq,
#[serde(rename = "IS")]
Is,
#[serde(rename = "IT")]
It,
#[serde(rename = "JE")]
Je,
#[serde(rename = "JM")]
Jm,
#[serde(rename = "JO")]
Jo,
#[serde(rename = "JP")]
Jp,
#[serde(rename = "KE")]
Ke,
#[serde(rename = "KG")]
Kg,
#[serde(rename = "KH")]
Kh,
#[serde(rename = "KI")]
Ki,
#[serde(rename = "KM")]
Km,
#[serde(rename = "KN")]
Kn,
#[serde(rename = "KR")]
Kr,
#[serde(rename = "KW")]
Kw,
#[serde(rename = "KY")]
Ky,
#[serde(rename = "KZ")]
Kz,
#[serde(rename = "LA")]
La,
#[serde(rename = "LB")]
Lb,
#[serde(rename = "LC")]
Lc,
#[serde(rename = "LI")]
Li,
#[serde(rename = "LK")]
Lk,
#[serde(rename = "LR")]
Lr,
#[serde(rename = "LS")]
Ls,
#[serde(rename = "LT")]
Lt,
#[serde(rename = "LU")]
Lu,
#[serde(rename = "LV")]
Lv,
#[serde(rename = "LY")]
Ly,
#[serde(rename = "MA")]
Ma,
#[serde(rename = "MC")]
Mc,
#[serde(rename = "MD")]
Md,
#[serde(rename = "ME")]
Me,
#[serde(rename = "MF")]
Mf,
#[serde(rename = "MG")]
Mg,
#[serde(rename = "MK")]
Mk,
#[serde(rename = "ML")]
Ml,
#[serde(rename = "MM")]
Mm,
#[serde(rename = "MN")]
Mn,
#[serde(rename = "MO")]
Mo,
#[serde(rename = "MQ")]
Mq,
#[serde(rename = "MR")]
Mr,
#[serde(rename = "MS")]
Ms,
#[serde(rename = "MT")]
Mt,
#[serde(rename = "MU")]
Mu,
#[serde(rename = "MV")]
Mv,
#[serde(rename = "MW")]
Mw,
#[serde(rename = "MX")]
Mx,
#[serde(rename = "MY")]
My,
#[serde(rename = "MZ")]
Mz,
#[serde(rename = "NA")]
Na,
#[serde(rename = "NC")]
Nc,
#[serde(rename = "NE")]
Ne,
#[serde(rename = "NG")]
Ng,
#[serde(rename = "NI")]
Ni,
#[serde(rename = "NL")]
Nl,
#[serde(rename = "NO")]
No,
#[serde(rename = "NP")]
Np,
#[serde(rename = "NR")]
Nr,
#[serde(rename = "NU")]
Nu,
#[serde(rename = "NZ")]
Nz,
#[serde(rename = "OM")]
Om,
#[serde(rename = "PA")]
Pa,
#[serde(rename = "PE")]
Pe,
#[serde(rename = "PF")]
Pf,
#[serde(rename = "PG")]
Pg,
#[serde(rename = "PH")]
Ph,
#[serde(rename = "PK")]
Pk,
#[serde(rename = "PL")]
Pl,
#[serde(rename = "PM")]
Pm,
#[serde(rename = "PN")]
Pn,
#[serde(rename = "PR")]
Pr,
#[serde(rename = "PS")]
Ps,
#[serde(rename = "PT")]
Pt,
#[serde(rename = "PY")]
Py,
#[serde(rename = "QA")]
Qa,
#[serde(rename = "RE")]
Re,
#[serde(rename = "RO")]
Ro,
#[serde(rename = "RS")]
Rs,
#[serde(rename = "RU")]
Ru,
#[serde(rename = "RW")]
Rw,
#[serde(rename = "SA")]
Sa,
#[serde(rename = "SB")]
Sb,
#[serde(rename = "SC")]
Sc,
#[serde(rename = "SE")]
Se,
#[serde(rename = "SG")]
Sg,
#[serde(rename = "SH")]
Sh,
#[serde(rename = "SI")]
Si,
#[serde(rename = "SJ")]
Sj,
#[serde(rename = "SK")]
Sk,
#[serde(rename = "SL")]
Sl,
#[serde(rename = "SM")]
Sm,
#[serde(rename = "SN")]
Sn,
#[serde(rename = "SO")]
So,
#[serde(rename = "SR")]
Sr,
#[serde(rename = "SS")]
Ss,
#[serde(rename = "ST")]
St,
#[serde(rename = "SV")]
Sv,
#[serde(rename = "SX")]
Sx,
#[serde(rename = "SZ")]
Sz,
#[serde(rename = "TA")]
Ta,
#[serde(rename = "TC")]
Tc,
#[serde(rename = "TD")]
Td,
#[serde(rename = "TF")]
Tf,
#[serde(rename = "TG")]
Tg,
#[serde(rename = "TH")]
Th,
#[serde(rename = "TJ")]
Tj,
#[serde(rename = "TK")]
Tk,
#[serde(rename = "TL")]
Tl,
#[serde(rename = "TM")]
Tm,
#[serde(rename = "TN")]
Tn,
#[serde(rename = "TO")]
To,
#[serde(rename = "TR")]
Tr,
#[serde(rename = "TT")]
Tt,
#[serde(rename = "TV")]
Tv,
#[serde(rename = "TW")]
Tw,
#[serde(rename = "TZ")]
Tz,
#[serde(rename = "UA")]
Ua,
#[serde(rename = "UG")]
Ug,
#[serde(rename = "US")]
Us,
#[serde(rename = "UY")]
Uy,
#[serde(rename = "UZ")]
Uz,
#[serde(rename = "VA")]
Va,
#[serde(rename = "VC")]
Vc,
#[serde(rename = "VE")]
Ve,
#[serde(rename = "VG")]
Vg,
#[serde(rename = "VN")]
Vn,
#[serde(rename = "VU")]
Vu,
#[serde(rename = "WF")]
Wf,
#[serde(rename = "WS")]
Ws,
#[serde(rename = "XK")]
Xk,
#[serde(rename = "YE")]
Ye,
#[serde(rename = "YT")]
Yt,
#[serde(rename = "ZA")]
Za,
#[serde(rename = "ZM")]
Zm,
#[serde(rename = "ZW")]
Zw,
#[serde(rename = "ZZ")]
Zz,
}
impl PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries {
pub fn as_str(self) -> &'static str {
match self {
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ac => "AC",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ad => "AD",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ae => "AE",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Af => "AF",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ag => "AG",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ai => "AI",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Al => "AL",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Am => "AM",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ao => "AO",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Aq => "AQ",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ar => "AR",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::At => "AT",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Au => "AU",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Aw => "AW",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ax => "AX",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Az => "AZ",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ba => "BA",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Bb => "BB",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Bd => "BD",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Be => "BE",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Bf => "BF",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Bg => "BG",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Bh => "BH",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Bi => "BI",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Bj => "BJ",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Bl => "BL",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Bm => "BM",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Bn => "BN",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Bo => "BO",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Bq => "BQ",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Br => "BR",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Bs => "BS",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Bt => "BT",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Bv => "BV",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Bw => "BW",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::By => "BY",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Bz => "BZ",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ca => "CA",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Cd => "CD",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Cf => "CF",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Cg => "CG",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ch => "CH",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ci => "CI",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ck => "CK",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Cl => "CL",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Cm => "CM",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Cn => "CN",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Co => "CO",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Cr => "CR",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Cv => "CV",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Cw => "CW",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Cy => "CY",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Cz => "CZ",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::De => "DE",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Dj => "DJ",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Dk => "DK",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Dm => "DM",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Do => "DO",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Dz => "DZ",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ec => "EC",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ee => "EE",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Eg => "EG",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Eh => "EH",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Er => "ER",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Es => "ES",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Et => "ET",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Fi => "FI",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Fj => "FJ",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Fk => "FK",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Fo => "FO",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Fr => "FR",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ga => "GA",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Gb => "GB",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Gd => "GD",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ge => "GE",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Gf => "GF",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Gg => "GG",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Gh => "GH",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Gi => "GI",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Gl => "GL",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Gm => "GM",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Gn => "GN",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Gp => "GP",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Gq => "GQ",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Gr => "GR",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Gs => "GS",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Gt => "GT",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Gu => "GU",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Gw => "GW",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Gy => "GY",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Hk => "HK",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Hn => "HN",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Hr => "HR",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ht => "HT",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Hu => "HU",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Id => "ID",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ie => "IE",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Il => "IL",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Im => "IM",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::In => "IN",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Io => "IO",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Iq => "IQ",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Is => "IS",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::It => "IT",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Je => "JE",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Jm => "JM",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Jo => "JO",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Jp => "JP",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ke => "KE",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Kg => "KG",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Kh => "KH",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ki => "KI",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Km => "KM",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Kn => "KN",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Kr => "KR",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Kw => "KW",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ky => "KY",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Kz => "KZ",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::La => "LA",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Lb => "LB",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Lc => "LC",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Li => "LI",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Lk => "LK",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Lr => "LR",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ls => "LS",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Lt => "LT",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Lu => "LU",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Lv => "LV",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ly => "LY",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ma => "MA",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Mc => "MC",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Md => "MD",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Me => "ME",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Mf => "MF",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Mg => "MG",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Mk => "MK",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ml => "ML",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Mm => "MM",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Mn => "MN",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Mo => "MO",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Mq => "MQ",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Mr => "MR",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ms => "MS",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Mt => "MT",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Mu => "MU",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Mv => "MV",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Mw => "MW",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Mx => "MX",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::My => "MY",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Mz => "MZ",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Na => "NA",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Nc => "NC",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ne => "NE",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ng => "NG",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ni => "NI",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Nl => "NL",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::No => "NO",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Np => "NP",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Nr => "NR",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Nu => "NU",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Nz => "NZ",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Om => "OM",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Pa => "PA",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Pe => "PE",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Pf => "PF",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Pg => "PG",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ph => "PH",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Pk => "PK",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Pl => "PL",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Pm => "PM",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Pn => "PN",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Pr => "PR",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ps => "PS",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Pt => "PT",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Py => "PY",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Qa => "QA",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Re => "RE",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ro => "RO",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Rs => "RS",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ru => "RU",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Rw => "RW",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Sa => "SA",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Sb => "SB",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Sc => "SC",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Se => "SE",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Sg => "SG",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Sh => "SH",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Si => "SI",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Sj => "SJ",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Sk => "SK",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Sl => "SL",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Sm => "SM",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Sn => "SN",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::So => "SO",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Sr => "SR",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ss => "SS",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::St => "ST",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Sv => "SV",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Sx => "SX",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Sz => "SZ",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ta => "TA",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Tc => "TC",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Td => "TD",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Tf => "TF",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Tg => "TG",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Th => "TH",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Tj => "TJ",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Tk => "TK",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Tl => "TL",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Tm => "TM",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Tn => "TN",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::To => "TO",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Tr => "TR",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Tt => "TT",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Tv => "TV",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Tw => "TW",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Tz => "TZ",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ua => "UA",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ug => "UG",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Us => "US",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Uy => "UY",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Uz => "UZ",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Va => "VA",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Vc => "VC",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ve => "VE",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Vg => "VG",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Vn => "VN",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Vu => "VU",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Wf => "WF",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ws => "WS",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Xk => "XK",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Ye => "YE",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Yt => "YT",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Za => "ZA",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Zm => "ZM",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Zw => "ZW",
PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries::Zz => "ZZ",
}
}
}
impl AsRef<str> for PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for PaymentPagesCheckoutSessionShippingAddressCollectionAllowedCountries
{
fn default() -> Self {
Self::Ac
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum PaymentPagesCheckoutSessionTaxIdType {
AdNrt,
AeTrn,
ArCuit,
AuAbn,
AuArn,
BgUic,
BoTin,
BrCnpj,
BrCpf,
CaBn,
CaGstHst,
CaPstBc,
CaPstMb,
CaPstSk,
CaQst,
ChVat,
ClTin,
CnTin,
CoNit,
CrTin,
DoRcn,
EcRuc,
EgTin,
EsCif,
EuOssVat,
EuVat,
GbVat,
GeVat,
HkBr,
HuTin,
IdNpwp,
IlVat,
InGst,
IsVat,
JpCn,
JpRn,
JpTrn,
KePin,
KrBrn,
LiUid,
MxRfc,
MyFrp,
MyItn,
MySst,
NoVat,
NzGst,
PeRuc,
PhTin,
RoTin,
RsPib,
RuInn,
RuKpp,
SaVat,
SgGst,
SgUen,
SiTin,
SvNit,
ThVat,
TrTin,
TwVat,
UaVat,
Unknown,
UsEin,
UyRuc,
VeRif,
VnTin,
ZaVat,
}
impl PaymentPagesCheckoutSessionTaxIdType {
pub fn as_str(self) -> &'static str {
match self {
PaymentPagesCheckoutSessionTaxIdType::AdNrt => "ad_nrt",
PaymentPagesCheckoutSessionTaxIdType::AeTrn => "ae_trn",
PaymentPagesCheckoutSessionTaxIdType::ArCuit => "ar_cuit",
PaymentPagesCheckoutSessionTaxIdType::AuAbn => "au_abn",
PaymentPagesCheckoutSessionTaxIdType::AuArn => "au_arn",
PaymentPagesCheckoutSessionTaxIdType::BgUic => "bg_uic",
PaymentPagesCheckoutSessionTaxIdType::BoTin => "bo_tin",
PaymentPagesCheckoutSessionTaxIdType::BrCnpj => "br_cnpj",
PaymentPagesCheckoutSessionTaxIdType::BrCpf => "br_cpf",
PaymentPagesCheckoutSessionTaxIdType::CaBn => "ca_bn",
PaymentPagesCheckoutSessionTaxIdType::CaGstHst => "ca_gst_hst",
PaymentPagesCheckoutSessionTaxIdType::CaPstBc => "ca_pst_bc",
PaymentPagesCheckoutSessionTaxIdType::CaPstMb => "ca_pst_mb",
PaymentPagesCheckoutSessionTaxIdType::CaPstSk => "ca_pst_sk",
PaymentPagesCheckoutSessionTaxIdType::CaQst => "ca_qst",
PaymentPagesCheckoutSessionTaxIdType::ChVat => "ch_vat",
PaymentPagesCheckoutSessionTaxIdType::ClTin => "cl_tin",
PaymentPagesCheckoutSessionTaxIdType::CnTin => "cn_tin",
PaymentPagesCheckoutSessionTaxIdType::CoNit => "co_nit",
PaymentPagesCheckoutSessionTaxIdType::CrTin => "cr_tin",
PaymentPagesCheckoutSessionTaxIdType::DoRcn => "do_rcn",
PaymentPagesCheckoutSessionTaxIdType::EcRuc => "ec_ruc",
PaymentPagesCheckoutSessionTaxIdType::EgTin => "eg_tin",
PaymentPagesCheckoutSessionTaxIdType::EsCif => "es_cif",
PaymentPagesCheckoutSessionTaxIdType::EuOssVat => "eu_oss_vat",
PaymentPagesCheckoutSessionTaxIdType::EuVat => "eu_vat",
PaymentPagesCheckoutSessionTaxIdType::GbVat => "gb_vat",
PaymentPagesCheckoutSessionTaxIdType::GeVat => "ge_vat",
PaymentPagesCheckoutSessionTaxIdType::HkBr => "hk_br",
PaymentPagesCheckoutSessionTaxIdType::HuTin => "hu_tin",
PaymentPagesCheckoutSessionTaxIdType::IdNpwp => "id_npwp",
PaymentPagesCheckoutSessionTaxIdType::IlVat => "il_vat",
PaymentPagesCheckoutSessionTaxIdType::InGst => "in_gst",
PaymentPagesCheckoutSessionTaxIdType::IsVat => "is_vat",
PaymentPagesCheckoutSessionTaxIdType::JpCn => "jp_cn",
PaymentPagesCheckoutSessionTaxIdType::JpRn => "jp_rn",
PaymentPagesCheckoutSessionTaxIdType::JpTrn => "jp_trn",
PaymentPagesCheckoutSessionTaxIdType::KePin => "ke_pin",
PaymentPagesCheckoutSessionTaxIdType::KrBrn => "kr_brn",
PaymentPagesCheckoutSessionTaxIdType::LiUid => "li_uid",
PaymentPagesCheckoutSessionTaxIdType::MxRfc => "mx_rfc",
PaymentPagesCheckoutSessionTaxIdType::MyFrp => "my_frp",
PaymentPagesCheckoutSessionTaxIdType::MyItn => "my_itn",
PaymentPagesCheckoutSessionTaxIdType::MySst => "my_sst",
PaymentPagesCheckoutSessionTaxIdType::NoVat => "no_vat",
PaymentPagesCheckoutSessionTaxIdType::NzGst => "nz_gst",
PaymentPagesCheckoutSessionTaxIdType::PeRuc => "pe_ruc",
PaymentPagesCheckoutSessionTaxIdType::PhTin => "ph_tin",
PaymentPagesCheckoutSessionTaxIdType::RoTin => "ro_tin",
PaymentPagesCheckoutSessionTaxIdType::RsPib => "rs_pib",
PaymentPagesCheckoutSessionTaxIdType::RuInn => "ru_inn",
PaymentPagesCheckoutSessionTaxIdType::RuKpp => "ru_kpp",
PaymentPagesCheckoutSessionTaxIdType::SaVat => "sa_vat",
PaymentPagesCheckoutSessionTaxIdType::SgGst => "sg_gst",
PaymentPagesCheckoutSessionTaxIdType::SgUen => "sg_uen",
PaymentPagesCheckoutSessionTaxIdType::SiTin => "si_tin",
PaymentPagesCheckoutSessionTaxIdType::SvNit => "sv_nit",
PaymentPagesCheckoutSessionTaxIdType::ThVat => "th_vat",
PaymentPagesCheckoutSessionTaxIdType::TrTin => "tr_tin",
PaymentPagesCheckoutSessionTaxIdType::TwVat => "tw_vat",
PaymentPagesCheckoutSessionTaxIdType::UaVat => "ua_vat",
PaymentPagesCheckoutSessionTaxIdType::Unknown => "unknown",
PaymentPagesCheckoutSessionTaxIdType::UsEin => "us_ein",
PaymentPagesCheckoutSessionTaxIdType::UyRuc => "uy_ruc",
PaymentPagesCheckoutSessionTaxIdType::VeRif => "ve_rif",
PaymentPagesCheckoutSessionTaxIdType::VnTin => "vn_tin",
PaymentPagesCheckoutSessionTaxIdType::ZaVat => "za_vat",
}
}
}
impl AsRef<str> for PaymentPagesCheckoutSessionTaxIdType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for PaymentPagesCheckoutSessionTaxIdType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for PaymentPagesCheckoutSessionTaxIdType {
fn default() -> Self {
Self::AdNrt
}
}