use serde::{Deserialize, Serialize};
use crate::client::{Client, Response};
use crate::ids::PaymentLinkId;
use crate::params::{Expand, Expandable, List, Metadata, Object, Paginable};
use crate::resources::{
Account, Application, CheckoutSessionItem, ConnectAccountReference, Currency,
InvoiceSettingRenderingOptions, ShippingRate, SubscriptionsTrialsResourceTrialSettings, TaxId,
};
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentLink {
pub id: PaymentLinkId,
pub active: bool,
pub after_completion: PaymentLinksResourceAfterCompletion,
pub allow_promotion_codes: bool,
pub application: Option<Expandable<Application>>,
pub application_fee_amount: Option<i64>,
pub application_fee_percent: Option<f64>,
pub automatic_tax: PaymentLinksResourceAutomaticTax,
pub billing_address_collection: PaymentLinkBillingAddressCollection,
pub consent_collection: Option<PaymentLinksResourceConsentCollection>,
pub currency: Currency,
pub custom_fields: Vec<PaymentLinksResourceCustomFields>,
pub custom_text: PaymentLinksResourceCustomText,
pub customer_creation: PaymentLinkCustomerCreation,
pub inactive_message: Option<String>,
pub invoice_creation: Option<PaymentLinksResourceInvoiceCreation>,
#[serde(skip_serializing_if = "Option::is_none")]
pub line_items: Option<List<CheckoutSessionItem>>,
pub livemode: bool,
pub metadata: Metadata,
pub on_behalf_of: Option<Expandable<Account>>,
pub payment_intent_data: Option<PaymentLinksResourcePaymentIntentData>,
pub payment_method_collection: PaymentLinkPaymentMethodCollection,
pub payment_method_types: Option<Vec<PaymentLinkPaymentMethodTypes>>,
pub phone_number_collection: PaymentLinksResourcePhoneNumberCollection,
pub restrictions: Option<PaymentLinksResourceRestrictions>,
pub shipping_address_collection: Option<PaymentLinksResourceShippingAddressCollection>,
pub shipping_options: Vec<PaymentLinksResourceShippingOption>,
pub submit_type: PaymentLinkSubmitType,
pub subscription_data: Option<PaymentLinksResourceSubscriptionData>,
pub tax_id_collection: PaymentLinksResourceTaxIdCollection,
pub transfer_data: Option<PaymentLinksResourceTransferData>,
pub url: String,
}
impl PaymentLink {
pub fn list(client: &Client, params: &ListPaymentLinks<'_>) -> Response<List<PaymentLink>> {
client.get_query("/payment_links", params)
}
pub fn create(client: &Client, params: CreatePaymentLink<'_>) -> Response<PaymentLink> {
#[allow(clippy::needless_borrows_for_generic_args)]
client.post_form("/payment_links", ¶ms)
}
pub fn retrieve(client: &Client, id: &PaymentLinkId, expand: &[&str]) -> Response<PaymentLink> {
client.get_query(&format!("/payment_links/{}", id), Expand { expand })
}
pub fn update(
client: &Client,
id: &PaymentLinkId,
params: UpdatePaymentLink<'_>,
) -> Response<PaymentLink> {
#[allow(clippy::needless_borrows_for_generic_args)]
client.post_form(&format!("/payment_links/{}", id), ¶ms)
}
}
impl Object for PaymentLink {
type Id = PaymentLinkId;
fn id(&self) -> Self::Id {
self.id.clone()
}
fn object(&self) -> &'static str {
"payment_link"
}
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentLinksResourceAfterCompletion {
#[serde(skip_serializing_if = "Option::is_none")]
pub hosted_confirmation: Option<PaymentLinksResourceCompletionBehaviorConfirmationPage>,
#[serde(skip_serializing_if = "Option::is_none")]
pub redirect: Option<PaymentLinksResourceCompletionBehaviorRedirect>,
#[serde(rename = "type")]
pub type_: PaymentLinksResourceAfterCompletionType,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentLinksResourceAutomaticTax {
pub enabled: bool,
pub liability: Option<ConnectAccountReference>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentLinksResourceCompletionBehaviorConfirmationPage {
pub custom_message: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentLinksResourceCompletionBehaviorRedirect {
pub url: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentLinksResourceConsentCollection {
pub payment_method_reuse_agreement: Option<PaymentLinksResourcePaymentMethodReuseAgreement>,
pub promotions: Option<PaymentLinksResourceConsentCollectionPromotions>,
pub terms_of_service: Option<PaymentLinksResourceConsentCollectionTermsOfService>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentLinksResourceCustomFields {
#[serde(skip_serializing_if = "Option::is_none")]
pub dropdown: Option<PaymentLinksResourceCustomFieldsDropdown>,
pub key: String,
pub label: PaymentLinksResourceCustomFieldsLabel,
#[serde(skip_serializing_if = "Option::is_none")]
pub numeric: Option<PaymentLinksResourceCustomFieldsNumeric>,
pub optional: bool,
#[serde(skip_serializing_if = "Option::is_none")]
pub text: Option<PaymentLinksResourceCustomFieldsText>,
#[serde(rename = "type")]
pub type_: PaymentLinksResourceCustomFieldsType,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentLinksResourceCustomFieldsDropdown {
pub options: Vec<PaymentLinksResourceCustomFieldsDropdownOption>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentLinksResourceCustomFieldsDropdownOption {
pub label: String,
pub value: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentLinksResourceCustomFieldsLabel {
pub custom: Option<String>,
#[serde(rename = "type")]
pub type_: PaymentLinksResourceCustomFieldsLabelType,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentLinksResourceCustomFieldsNumeric {
pub maximum_length: Option<i64>,
pub minimum_length: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentLinksResourceCustomFieldsText {
pub maximum_length: Option<i64>,
pub minimum_length: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentLinksResourceCustomText {
pub after_submit: Option<PaymentLinksResourceCustomTextPosition>,
pub shipping_address: Option<PaymentLinksResourceCustomTextPosition>,
pub submit: Option<PaymentLinksResourceCustomTextPosition>,
pub terms_of_service_acceptance: Option<PaymentLinksResourceCustomTextPosition>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentLinksResourceCustomTextPosition {
pub message: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentLinksResourceInvoiceCreation {
pub enabled: bool,
pub invoice_data: Option<PaymentLinksResourceInvoiceSettings>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentLinksResourceInvoiceSettings {
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 PaymentLinksResourcePaymentIntentData {
pub capture_method: Option<PaymentLinksResourcePaymentIntentDataCaptureMethod>,
pub description: Option<String>,
pub metadata: Metadata,
pub setup_future_usage: Option<PaymentLinksResourcePaymentIntentDataSetupFutureUsage>,
pub statement_descriptor: Option<String>,
pub statement_descriptor_suffix: Option<String>,
pub transfer_group: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentLinksResourcePaymentMethodReuseAgreement {
pub position: PaymentLinksResourcePaymentMethodReuseAgreementPosition,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentLinksResourcePhoneNumberCollection {
pub enabled: bool,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentLinksResourceRestrictions {
pub completed_sessions: PaymentLinksResourceCompletedSessions,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentLinksResourceCompletedSessions {
pub count: u64,
pub limit: i64,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentLinksResourceShippingAddressCollection {
pub allowed_countries: Vec<PaymentLinksResourceShippingAddressCollectionAllowedCountries>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentLinksResourceShippingOption {
pub shipping_amount: i64,
pub shipping_rate: Expandable<ShippingRate>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentLinksResourceSubscriptionData {
pub description: Option<String>,
pub invoice_settings: PaymentLinksResourceSubscriptionDataInvoiceSettings,
pub metadata: Metadata,
pub trial_period_days: Option<u32>,
pub trial_settings: Option<SubscriptionsTrialsResourceTrialSettings>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentLinksResourceSubscriptionDataInvoiceSettings {
pub issuer: ConnectAccountReference,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentLinksResourceTaxIdCollection {
pub enabled: bool,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct PaymentLinksResourceTransferData {
pub amount: Option<i64>,
pub destination: Expandable<Account>,
}
#[derive(Clone, Debug, Serialize)]
pub struct CreatePaymentLink<'a> {
#[serde(skip_serializing_if = "Option::is_none")]
pub after_completion: Option<CreatePaymentLinkAfterCompletion>,
#[serde(skip_serializing_if = "Option::is_none")]
pub allow_promotion_codes: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub application_fee_amount: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub application_fee_percent: Option<f64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub automatic_tax: Option<CreatePaymentLinkAutomaticTax>,
#[serde(skip_serializing_if = "Option::is_none")]
pub billing_address_collection: Option<PaymentLinkBillingAddressCollection>,
#[serde(skip_serializing_if = "Option::is_none")]
pub consent_collection: Option<CreatePaymentLinkConsentCollection>,
#[serde(skip_serializing_if = "Option::is_none")]
pub currency: Option<Currency>,
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_fields: Option<Vec<CreatePaymentLinkCustomFields>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_text: Option<CreatePaymentLinkCustomText>,
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_creation: Option<PaymentLinkCustomerCreation>,
#[serde(skip_serializing_if = "Expand::is_empty")]
pub expand: &'a [&'a str],
#[serde(skip_serializing_if = "Option::is_none")]
pub inactive_message: Option<&'a str>,
#[serde(skip_serializing_if = "Option::is_none")]
pub invoice_creation: Option<CreatePaymentLinkInvoiceCreation>,
pub line_items: Vec<CreatePaymentLinkLineItems>,
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata: Option<Metadata>,
#[serde(skip_serializing_if = "Option::is_none")]
pub on_behalf_of: Option<&'a str>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_intent_data: Option<CreatePaymentLinkPaymentIntentData>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method_collection: Option<PaymentLinkPaymentMethodCollection>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method_types: Option<Vec<CreatePaymentLinkPaymentMethodTypes>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub phone_number_collection: Option<CreatePaymentLinkPhoneNumberCollection>,
#[serde(skip_serializing_if = "Option::is_none")]
pub restrictions: Option<CreatePaymentLinkRestrictions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub shipping_address_collection: Option<CreatePaymentLinkShippingAddressCollection>,
#[serde(skip_serializing_if = "Option::is_none")]
pub shipping_options: Option<Vec<CreatePaymentLinkShippingOptions>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub submit_type: Option<PaymentLinkSubmitType>,
#[serde(skip_serializing_if = "Option::is_none")]
pub subscription_data: Option<CreatePaymentLinkSubscriptionData>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tax_id_collection: Option<CreatePaymentLinkTaxIdCollection>,
#[serde(skip_serializing_if = "Option::is_none")]
pub transfer_data: Option<CreatePaymentLinkTransferData>,
}
impl<'a> CreatePaymentLink<'a> {
pub fn new(line_items: Vec<CreatePaymentLinkLineItems>) -> Self {
CreatePaymentLink {
after_completion: Default::default(),
allow_promotion_codes: Default::default(),
application_fee_amount: Default::default(),
application_fee_percent: Default::default(),
automatic_tax: Default::default(),
billing_address_collection: Default::default(),
consent_collection: Default::default(),
currency: Default::default(),
custom_fields: Default::default(),
custom_text: Default::default(),
customer_creation: Default::default(),
expand: Default::default(),
inactive_message: Default::default(),
invoice_creation: Default::default(),
line_items,
metadata: Default::default(),
on_behalf_of: Default::default(),
payment_intent_data: Default::default(),
payment_method_collection: Default::default(),
payment_method_types: Default::default(),
phone_number_collection: Default::default(),
restrictions: Default::default(),
shipping_address_collection: Default::default(),
shipping_options: Default::default(),
submit_type: Default::default(),
subscription_data: Default::default(),
tax_id_collection: Default::default(),
transfer_data: Default::default(),
}
}
}
#[derive(Clone, Debug, Serialize, Default)]
pub struct ListPaymentLinks<'a> {
#[serde(skip_serializing_if = "Option::is_none")]
pub active: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub ending_before: Option<PaymentLinkId>,
#[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 starting_after: Option<PaymentLinkId>,
}
impl<'a> ListPaymentLinks<'a> {
pub fn new() -> Self {
ListPaymentLinks {
active: Default::default(),
ending_before: Default::default(),
expand: Default::default(),
limit: Default::default(),
starting_after: Default::default(),
}
}
}
impl Paginable for ListPaymentLinks<'_> {
type O = PaymentLink;
fn set_last(&mut self, item: Self::O) {
self.starting_after = Some(item.id());
}
}
#[derive(Clone, Debug, Serialize, Default)]
pub struct UpdatePaymentLink<'a> {
#[serde(skip_serializing_if = "Option::is_none")]
pub active: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub after_completion: Option<UpdatePaymentLinkAfterCompletion>,
#[serde(skip_serializing_if = "Option::is_none")]
pub allow_promotion_codes: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub automatic_tax: Option<UpdatePaymentLinkAutomaticTax>,
#[serde(skip_serializing_if = "Option::is_none")]
pub billing_address_collection: Option<PaymentLinkBillingAddressCollection>,
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_fields: Option<Vec<UpdatePaymentLinkCustomFields>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_text: Option<UpdatePaymentLinkCustomText>,
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_creation: Option<PaymentLinkCustomerCreation>,
#[serde(skip_serializing_if = "Expand::is_empty")]
pub expand: &'a [&'a str],
#[serde(skip_serializing_if = "Option::is_none")]
pub inactive_message: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub invoice_creation: Option<UpdatePaymentLinkInvoiceCreation>,
#[serde(skip_serializing_if = "Option::is_none")]
pub line_items: Option<Vec<UpdatePaymentLinkLineItems>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata: Option<Metadata>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_intent_data: Option<UpdatePaymentLinkPaymentIntentData>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method_collection: Option<PaymentLinkPaymentMethodCollection>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method_types: Option<Vec<UpdatePaymentLinkPaymentMethodTypes>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub restrictions: Option<UpdatePaymentLinkRestrictions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub shipping_address_collection: Option<UpdatePaymentLinkShippingAddressCollection>,
#[serde(skip_serializing_if = "Option::is_none")]
pub subscription_data: Option<UpdatePaymentLinkSubscriptionData>,
}
impl<'a> UpdatePaymentLink<'a> {
pub fn new() -> Self {
UpdatePaymentLink {
active: Default::default(),
after_completion: Default::default(),
allow_promotion_codes: Default::default(),
automatic_tax: Default::default(),
billing_address_collection: Default::default(),
custom_fields: Default::default(),
custom_text: Default::default(),
customer_creation: Default::default(),
expand: Default::default(),
inactive_message: Default::default(),
invoice_creation: Default::default(),
line_items: Default::default(),
metadata: Default::default(),
payment_intent_data: Default::default(),
payment_method_collection: Default::default(),
payment_method_types: Default::default(),
restrictions: Default::default(),
shipping_address_collection: Default::default(),
subscription_data: Default::default(),
}
}
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkAfterCompletion {
#[serde(skip_serializing_if = "Option::is_none")]
pub hosted_confirmation: Option<CreatePaymentLinkAfterCompletionHostedConfirmation>,
#[serde(skip_serializing_if = "Option::is_none")]
pub redirect: Option<CreatePaymentLinkAfterCompletionRedirect>,
#[serde(rename = "type")]
pub type_: CreatePaymentLinkAfterCompletionType,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkAutomaticTax {
pub enabled: bool,
#[serde(skip_serializing_if = "Option::is_none")]
pub liability: Option<CreatePaymentLinkAutomaticTaxLiability>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkConsentCollection {
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method_reuse_agreement:
Option<CreatePaymentLinkConsentCollectionPaymentMethodReuseAgreement>,
#[serde(skip_serializing_if = "Option::is_none")]
pub promotions: Option<CreatePaymentLinkConsentCollectionPromotions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub terms_of_service: Option<CreatePaymentLinkConsentCollectionTermsOfService>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkCustomFields {
#[serde(skip_serializing_if = "Option::is_none")]
pub dropdown: Option<CreatePaymentLinkCustomFieldsDropdown>,
pub key: String,
pub label: CreatePaymentLinkCustomFieldsLabel,
#[serde(skip_serializing_if = "Option::is_none")]
pub numeric: Option<CreatePaymentLinkCustomFieldsNumeric>,
#[serde(skip_serializing_if = "Option::is_none")]
pub optional: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub text: Option<CreatePaymentLinkCustomFieldsText>,
#[serde(rename = "type")]
pub type_: CreatePaymentLinkCustomFieldsType,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkCustomText {
#[serde(skip_serializing_if = "Option::is_none")]
pub after_submit: Option<CreatePaymentLinkCustomTextAfterSubmit>,
#[serde(skip_serializing_if = "Option::is_none")]
pub shipping_address: Option<CreatePaymentLinkCustomTextShippingAddress>,
#[serde(skip_serializing_if = "Option::is_none")]
pub submit: Option<CreatePaymentLinkCustomTextSubmit>,
#[serde(skip_serializing_if = "Option::is_none")]
pub terms_of_service_acceptance: Option<CreatePaymentLinkCustomTextTermsOfServiceAcceptance>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkInvoiceCreation {
pub enabled: bool,
#[serde(skip_serializing_if = "Option::is_none")]
pub invoice_data: Option<CreatePaymentLinkInvoiceCreationInvoiceData>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkLineItems {
#[serde(skip_serializing_if = "Option::is_none")]
pub adjustable_quantity: Option<CreatePaymentLinkLineItemsAdjustableQuantity>,
pub price: String,
pub quantity: u64,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkPaymentIntentData {
#[serde(skip_serializing_if = "Option::is_none")]
pub capture_method: Option<CreatePaymentLinkPaymentIntentDataCaptureMethod>,
#[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 setup_future_usage: Option<CreatePaymentLinkPaymentIntentDataSetupFutureUsage>,
#[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_group: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkPhoneNumberCollection {
pub enabled: bool,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkRestrictions {
pub completed_sessions: CreatePaymentLinkRestrictionsCompletedSessions,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkShippingAddressCollection {
pub allowed_countries: Vec<CreatePaymentLinkShippingAddressCollectionAllowedCountries>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkShippingOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub shipping_rate: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkSubscriptionData {
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub invoice_settings: Option<CreatePaymentLinkSubscriptionDataInvoiceSettings>,
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata: Option<Metadata>,
#[serde(skip_serializing_if = "Option::is_none")]
pub trial_period_days: Option<u32>,
#[serde(skip_serializing_if = "Option::is_none")]
pub trial_settings: Option<CreatePaymentLinkSubscriptionDataTrialSettings>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkTaxIdCollection {
pub enabled: bool,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkTransferData {
#[serde(skip_serializing_if = "Option::is_none")]
pub amount: Option<i64>,
pub destination: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct UpdatePaymentLinkAfterCompletion {
#[serde(skip_serializing_if = "Option::is_none")]
pub hosted_confirmation: Option<UpdatePaymentLinkAfterCompletionHostedConfirmation>,
#[serde(skip_serializing_if = "Option::is_none")]
pub redirect: Option<UpdatePaymentLinkAfterCompletionRedirect>,
#[serde(rename = "type")]
pub type_: UpdatePaymentLinkAfterCompletionType,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct UpdatePaymentLinkAutomaticTax {
pub enabled: bool,
#[serde(skip_serializing_if = "Option::is_none")]
pub liability: Option<UpdatePaymentLinkAutomaticTaxLiability>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct UpdatePaymentLinkCustomFields {
#[serde(skip_serializing_if = "Option::is_none")]
pub dropdown: Option<UpdatePaymentLinkCustomFieldsDropdown>,
pub key: String,
pub label: UpdatePaymentLinkCustomFieldsLabel,
#[serde(skip_serializing_if = "Option::is_none")]
pub numeric: Option<UpdatePaymentLinkCustomFieldsNumeric>,
#[serde(skip_serializing_if = "Option::is_none")]
pub optional: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub text: Option<UpdatePaymentLinkCustomFieldsText>,
#[serde(rename = "type")]
pub type_: UpdatePaymentLinkCustomFieldsType,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct UpdatePaymentLinkCustomText {
#[serde(skip_serializing_if = "Option::is_none")]
pub after_submit: Option<UpdatePaymentLinkCustomTextAfterSubmit>,
#[serde(skip_serializing_if = "Option::is_none")]
pub shipping_address: Option<UpdatePaymentLinkCustomTextShippingAddress>,
#[serde(skip_serializing_if = "Option::is_none")]
pub submit: Option<UpdatePaymentLinkCustomTextSubmit>,
#[serde(skip_serializing_if = "Option::is_none")]
pub terms_of_service_acceptance: Option<UpdatePaymentLinkCustomTextTermsOfServiceAcceptance>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct UpdatePaymentLinkInvoiceCreation {
pub enabled: bool,
#[serde(skip_serializing_if = "Option::is_none")]
pub invoice_data: Option<UpdatePaymentLinkInvoiceCreationInvoiceData>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct UpdatePaymentLinkLineItems {
#[serde(skip_serializing_if = "Option::is_none")]
pub adjustable_quantity: Option<UpdatePaymentLinkLineItemsAdjustableQuantity>,
pub id: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub quantity: Option<u64>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct UpdatePaymentLinkPaymentIntentData {
#[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 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_group: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct UpdatePaymentLinkRestrictions {
pub completed_sessions: UpdatePaymentLinkRestrictionsCompletedSessions,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct UpdatePaymentLinkShippingAddressCollection {
pub allowed_countries: Vec<UpdatePaymentLinkShippingAddressCollectionAllowedCountries>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct UpdatePaymentLinkSubscriptionData {
#[serde(skip_serializing_if = "Option::is_none")]
pub invoice_settings: Option<UpdatePaymentLinkSubscriptionDataInvoiceSettings>,
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata: Option<Metadata>,
#[serde(skip_serializing_if = "Option::is_none")]
pub trial_settings: Option<UpdatePaymentLinkSubscriptionDataTrialSettings>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkAfterCompletionHostedConfirmation {
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_message: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkAfterCompletionRedirect {
pub url: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkAutomaticTaxLiability {
#[serde(skip_serializing_if = "Option::is_none")]
pub account: Option<String>,
#[serde(rename = "type")]
pub type_: CreatePaymentLinkAutomaticTaxLiabilityType,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkConsentCollectionPaymentMethodReuseAgreement {
pub position: CreatePaymentLinkConsentCollectionPaymentMethodReuseAgreementPosition,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkCustomFieldsDropdown {
pub options: Vec<CreatePaymentLinkCustomFieldsDropdownOptions>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkCustomFieldsLabel {
pub custom: String,
#[serde(rename = "type")]
pub type_: CreatePaymentLinkCustomFieldsLabelType,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkCustomFieldsNumeric {
#[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 CreatePaymentLinkCustomFieldsText {
#[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 CreatePaymentLinkCustomTextAfterSubmit {
pub message: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkCustomTextShippingAddress {
pub message: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkCustomTextSubmit {
pub message: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkCustomTextTermsOfServiceAcceptance {
pub message: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkInvoiceCreationInvoiceData {
#[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<CreatePaymentLinkInvoiceCreationInvoiceDataCustomFields>>,
#[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<CreatePaymentLinkInvoiceCreationInvoiceDataIssuer>,
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata: Option<Metadata>,
#[serde(skip_serializing_if = "Option::is_none")]
pub rendering_options: Option<CreatePaymentLinkInvoiceCreationInvoiceDataRenderingOptions>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkLineItemsAdjustableQuantity {
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 CreatePaymentLinkRestrictionsCompletedSessions {
pub limit: i64,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkSubscriptionDataInvoiceSettings {
#[serde(skip_serializing_if = "Option::is_none")]
pub issuer: Option<CreatePaymentLinkSubscriptionDataInvoiceSettingsIssuer>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkSubscriptionDataTrialSettings {
pub end_behavior: CreatePaymentLinkSubscriptionDataTrialSettingsEndBehavior,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct UpdatePaymentLinkAfterCompletionHostedConfirmation {
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_message: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct UpdatePaymentLinkAfterCompletionRedirect {
pub url: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct UpdatePaymentLinkAutomaticTaxLiability {
#[serde(skip_serializing_if = "Option::is_none")]
pub account: Option<String>,
#[serde(rename = "type")]
pub type_: UpdatePaymentLinkAutomaticTaxLiabilityType,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct UpdatePaymentLinkCustomFieldsDropdown {
pub options: Vec<UpdatePaymentLinkCustomFieldsDropdownOptions>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct UpdatePaymentLinkCustomFieldsLabel {
pub custom: String,
#[serde(rename = "type")]
pub type_: UpdatePaymentLinkCustomFieldsLabelType,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct UpdatePaymentLinkCustomFieldsNumeric {
#[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 UpdatePaymentLinkCustomFieldsText {
#[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 UpdatePaymentLinkCustomTextAfterSubmit {
pub message: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct UpdatePaymentLinkCustomTextShippingAddress {
pub message: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct UpdatePaymentLinkCustomTextSubmit {
pub message: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct UpdatePaymentLinkCustomTextTermsOfServiceAcceptance {
pub message: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct UpdatePaymentLinkInvoiceCreationInvoiceData {
#[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<UpdatePaymentLinkInvoiceCreationInvoiceDataCustomFields>>,
#[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<UpdatePaymentLinkInvoiceCreationInvoiceDataIssuer>,
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata: Option<Metadata>,
#[serde(skip_serializing_if = "Option::is_none")]
pub rendering_options: Option<UpdatePaymentLinkInvoiceCreationInvoiceDataRenderingOptions>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct UpdatePaymentLinkLineItemsAdjustableQuantity {
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 UpdatePaymentLinkRestrictionsCompletedSessions {
pub limit: i64,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct UpdatePaymentLinkSubscriptionDataInvoiceSettings {
#[serde(skip_serializing_if = "Option::is_none")]
pub issuer: Option<UpdatePaymentLinkSubscriptionDataInvoiceSettingsIssuer>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct UpdatePaymentLinkSubscriptionDataTrialSettings {
pub end_behavior: UpdatePaymentLinkSubscriptionDataTrialSettingsEndBehavior,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkCustomFieldsDropdownOptions {
pub label: String,
pub value: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkInvoiceCreationInvoiceDataCustomFields {
pub name: String,
pub value: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkInvoiceCreationInvoiceDataIssuer {
#[serde(skip_serializing_if = "Option::is_none")]
pub account: Option<String>,
#[serde(rename = "type")]
pub type_: CreatePaymentLinkInvoiceCreationInvoiceDataIssuerType,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkInvoiceCreationInvoiceDataRenderingOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub amount_tax_display:
Option<CreatePaymentLinkInvoiceCreationInvoiceDataRenderingOptionsAmountTaxDisplay>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkSubscriptionDataInvoiceSettingsIssuer {
#[serde(skip_serializing_if = "Option::is_none")]
pub account: Option<String>,
#[serde(rename = "type")]
pub type_: CreatePaymentLinkSubscriptionDataInvoiceSettingsIssuerType,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreatePaymentLinkSubscriptionDataTrialSettingsEndBehavior {
pub missing_payment_method:
CreatePaymentLinkSubscriptionDataTrialSettingsEndBehaviorMissingPaymentMethod,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct UpdatePaymentLinkCustomFieldsDropdownOptions {
pub label: String,
pub value: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct UpdatePaymentLinkInvoiceCreationInvoiceDataCustomFields {
pub name: String,
pub value: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct UpdatePaymentLinkInvoiceCreationInvoiceDataIssuer {
#[serde(skip_serializing_if = "Option::is_none")]
pub account: Option<String>,
#[serde(rename = "type")]
pub type_: UpdatePaymentLinkInvoiceCreationInvoiceDataIssuerType,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct UpdatePaymentLinkInvoiceCreationInvoiceDataRenderingOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub amount_tax_display:
Option<UpdatePaymentLinkInvoiceCreationInvoiceDataRenderingOptionsAmountTaxDisplay>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct UpdatePaymentLinkSubscriptionDataInvoiceSettingsIssuer {
#[serde(skip_serializing_if = "Option::is_none")]
pub account: Option<String>,
#[serde(rename = "type")]
pub type_: UpdatePaymentLinkSubscriptionDataInvoiceSettingsIssuerType,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct UpdatePaymentLinkSubscriptionDataTrialSettingsEndBehavior {
pub missing_payment_method:
UpdatePaymentLinkSubscriptionDataTrialSettingsEndBehaviorMissingPaymentMethod,
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreatePaymentLinkAfterCompletionType {
HostedConfirmation,
Redirect,
}
impl CreatePaymentLinkAfterCompletionType {
pub fn as_str(self) -> &'static str {
match self {
CreatePaymentLinkAfterCompletionType::HostedConfirmation => "hosted_confirmation",
CreatePaymentLinkAfterCompletionType::Redirect => "redirect",
}
}
}
impl AsRef<str> for CreatePaymentLinkAfterCompletionType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreatePaymentLinkAfterCompletionType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreatePaymentLinkAfterCompletionType {
fn default() -> Self {
Self::HostedConfirmation
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreatePaymentLinkAutomaticTaxLiabilityType {
Account,
#[serde(rename = "self")]
Self_,
}
impl CreatePaymentLinkAutomaticTaxLiabilityType {
pub fn as_str(self) -> &'static str {
match self {
CreatePaymentLinkAutomaticTaxLiabilityType::Account => "account",
CreatePaymentLinkAutomaticTaxLiabilityType::Self_ => "self",
}
}
}
impl AsRef<str> for CreatePaymentLinkAutomaticTaxLiabilityType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreatePaymentLinkAutomaticTaxLiabilityType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreatePaymentLinkAutomaticTaxLiabilityType {
fn default() -> Self {
Self::Account
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreatePaymentLinkConsentCollectionPaymentMethodReuseAgreementPosition {
Auto,
Hidden,
}
impl CreatePaymentLinkConsentCollectionPaymentMethodReuseAgreementPosition {
pub fn as_str(self) -> &'static str {
match self {
CreatePaymentLinkConsentCollectionPaymentMethodReuseAgreementPosition::Auto => "auto",
CreatePaymentLinkConsentCollectionPaymentMethodReuseAgreementPosition::Hidden => {
"hidden"
}
}
}
}
impl AsRef<str> for CreatePaymentLinkConsentCollectionPaymentMethodReuseAgreementPosition {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreatePaymentLinkConsentCollectionPaymentMethodReuseAgreementPosition {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CreatePaymentLinkConsentCollectionPaymentMethodReuseAgreementPosition
{
fn default() -> Self {
Self::Auto
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreatePaymentLinkConsentCollectionPromotions {
Auto,
None,
}
impl CreatePaymentLinkConsentCollectionPromotions {
pub fn as_str(self) -> &'static str {
match self {
CreatePaymentLinkConsentCollectionPromotions::Auto => "auto",
CreatePaymentLinkConsentCollectionPromotions::None => "none",
}
}
}
impl AsRef<str> for CreatePaymentLinkConsentCollectionPromotions {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreatePaymentLinkConsentCollectionPromotions {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreatePaymentLinkConsentCollectionPromotions {
fn default() -> Self {
Self::Auto
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreatePaymentLinkConsentCollectionTermsOfService {
None,
Required,
}
impl CreatePaymentLinkConsentCollectionTermsOfService {
pub fn as_str(self) -> &'static str {
match self {
CreatePaymentLinkConsentCollectionTermsOfService::None => "none",
CreatePaymentLinkConsentCollectionTermsOfService::Required => "required",
}
}
}
impl AsRef<str> for CreatePaymentLinkConsentCollectionTermsOfService {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreatePaymentLinkConsentCollectionTermsOfService {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreatePaymentLinkConsentCollectionTermsOfService {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreatePaymentLinkCustomFieldsLabelType {
Custom,
}
impl CreatePaymentLinkCustomFieldsLabelType {
pub fn as_str(self) -> &'static str {
match self {
CreatePaymentLinkCustomFieldsLabelType::Custom => "custom",
}
}
}
impl AsRef<str> for CreatePaymentLinkCustomFieldsLabelType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreatePaymentLinkCustomFieldsLabelType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreatePaymentLinkCustomFieldsLabelType {
fn default() -> Self {
Self::Custom
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreatePaymentLinkCustomFieldsType {
Dropdown,
Numeric,
Text,
}
impl CreatePaymentLinkCustomFieldsType {
pub fn as_str(self) -> &'static str {
match self {
CreatePaymentLinkCustomFieldsType::Dropdown => "dropdown",
CreatePaymentLinkCustomFieldsType::Numeric => "numeric",
CreatePaymentLinkCustomFieldsType::Text => "text",
}
}
}
impl AsRef<str> for CreatePaymentLinkCustomFieldsType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreatePaymentLinkCustomFieldsType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreatePaymentLinkCustomFieldsType {
fn default() -> Self {
Self::Dropdown
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreatePaymentLinkInvoiceCreationInvoiceDataIssuerType {
Account,
#[serde(rename = "self")]
Self_,
}
impl CreatePaymentLinkInvoiceCreationInvoiceDataIssuerType {
pub fn as_str(self) -> &'static str {
match self {
CreatePaymentLinkInvoiceCreationInvoiceDataIssuerType::Account => "account",
CreatePaymentLinkInvoiceCreationInvoiceDataIssuerType::Self_ => "self",
}
}
}
impl AsRef<str> for CreatePaymentLinkInvoiceCreationInvoiceDataIssuerType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreatePaymentLinkInvoiceCreationInvoiceDataIssuerType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreatePaymentLinkInvoiceCreationInvoiceDataIssuerType {
fn default() -> Self {
Self::Account
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreatePaymentLinkInvoiceCreationInvoiceDataRenderingOptionsAmountTaxDisplay {
ExcludeTax,
IncludeInclusiveTax,
}
impl CreatePaymentLinkInvoiceCreationInvoiceDataRenderingOptionsAmountTaxDisplay {
pub fn as_str(self) -> &'static str {
match self {
CreatePaymentLinkInvoiceCreationInvoiceDataRenderingOptionsAmountTaxDisplay::ExcludeTax => "exclude_tax",
CreatePaymentLinkInvoiceCreationInvoiceDataRenderingOptionsAmountTaxDisplay::IncludeInclusiveTax => "include_inclusive_tax",
}
}
}
impl AsRef<str> for CreatePaymentLinkInvoiceCreationInvoiceDataRenderingOptionsAmountTaxDisplay {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display
for CreatePaymentLinkInvoiceCreationInvoiceDataRenderingOptionsAmountTaxDisplay
{
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CreatePaymentLinkInvoiceCreationInvoiceDataRenderingOptionsAmountTaxDisplay
{
fn default() -> Self {
Self::ExcludeTax
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreatePaymentLinkPaymentIntentDataCaptureMethod {
Automatic,
AutomaticAsync,
Manual,
}
impl CreatePaymentLinkPaymentIntentDataCaptureMethod {
pub fn as_str(self) -> &'static str {
match self {
CreatePaymentLinkPaymentIntentDataCaptureMethod::Automatic => "automatic",
CreatePaymentLinkPaymentIntentDataCaptureMethod::AutomaticAsync => "automatic_async",
CreatePaymentLinkPaymentIntentDataCaptureMethod::Manual => "manual",
}
}
}
impl AsRef<str> for CreatePaymentLinkPaymentIntentDataCaptureMethod {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreatePaymentLinkPaymentIntentDataCaptureMethod {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreatePaymentLinkPaymentIntentDataCaptureMethod {
fn default() -> Self {
Self::Automatic
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreatePaymentLinkPaymentIntentDataSetupFutureUsage {
OffSession,
OnSession,
}
impl CreatePaymentLinkPaymentIntentDataSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
CreatePaymentLinkPaymentIntentDataSetupFutureUsage::OffSession => "off_session",
CreatePaymentLinkPaymentIntentDataSetupFutureUsage::OnSession => "on_session",
}
}
}
impl AsRef<str> for CreatePaymentLinkPaymentIntentDataSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreatePaymentLinkPaymentIntentDataSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreatePaymentLinkPaymentIntentDataSetupFutureUsage {
fn default() -> Self {
Self::OffSession
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreatePaymentLinkPaymentMethodTypes {
Affirm,
AfterpayClearpay,
Alipay,
AuBecsDebit,
BacsDebit,
Bancontact,
Blik,
Boleto,
Card,
Cashapp,
Eps,
Fpx,
Giropay,
Grabpay,
Ideal,
Klarna,
Konbini,
Link,
Oxxo,
P24,
Paynow,
Paypal,
Pix,
Promptpay,
SepaDebit,
Sofort,
Swish,
UsBankAccount,
WechatPay,
}
impl CreatePaymentLinkPaymentMethodTypes {
pub fn as_str(self) -> &'static str {
match self {
CreatePaymentLinkPaymentMethodTypes::Affirm => "affirm",
CreatePaymentLinkPaymentMethodTypes::AfterpayClearpay => "afterpay_clearpay",
CreatePaymentLinkPaymentMethodTypes::Alipay => "alipay",
CreatePaymentLinkPaymentMethodTypes::AuBecsDebit => "au_becs_debit",
CreatePaymentLinkPaymentMethodTypes::BacsDebit => "bacs_debit",
CreatePaymentLinkPaymentMethodTypes::Bancontact => "bancontact",
CreatePaymentLinkPaymentMethodTypes::Blik => "blik",
CreatePaymentLinkPaymentMethodTypes::Boleto => "boleto",
CreatePaymentLinkPaymentMethodTypes::Card => "card",
CreatePaymentLinkPaymentMethodTypes::Cashapp => "cashapp",
CreatePaymentLinkPaymentMethodTypes::Eps => "eps",
CreatePaymentLinkPaymentMethodTypes::Fpx => "fpx",
CreatePaymentLinkPaymentMethodTypes::Giropay => "giropay",
CreatePaymentLinkPaymentMethodTypes::Grabpay => "grabpay",
CreatePaymentLinkPaymentMethodTypes::Ideal => "ideal",
CreatePaymentLinkPaymentMethodTypes::Klarna => "klarna",
CreatePaymentLinkPaymentMethodTypes::Konbini => "konbini",
CreatePaymentLinkPaymentMethodTypes::Link => "link",
CreatePaymentLinkPaymentMethodTypes::Oxxo => "oxxo",
CreatePaymentLinkPaymentMethodTypes::P24 => "p24",
CreatePaymentLinkPaymentMethodTypes::Paynow => "paynow",
CreatePaymentLinkPaymentMethodTypes::Paypal => "paypal",
CreatePaymentLinkPaymentMethodTypes::Pix => "pix",
CreatePaymentLinkPaymentMethodTypes::Promptpay => "promptpay",
CreatePaymentLinkPaymentMethodTypes::SepaDebit => "sepa_debit",
CreatePaymentLinkPaymentMethodTypes::Sofort => "sofort",
CreatePaymentLinkPaymentMethodTypes::Swish => "swish",
CreatePaymentLinkPaymentMethodTypes::UsBankAccount => "us_bank_account",
CreatePaymentLinkPaymentMethodTypes::WechatPay => "wechat_pay",
}
}
}
impl AsRef<str> for CreatePaymentLinkPaymentMethodTypes {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreatePaymentLinkPaymentMethodTypes {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreatePaymentLinkPaymentMethodTypes {
fn default() -> Self {
Self::Affirm
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreatePaymentLinkShippingAddressCollectionAllowedCountries {
#[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 CreatePaymentLinkShippingAddressCollectionAllowedCountries {
pub fn as_str(self) -> &'static str {
match self {
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ac => "AC",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ad => "AD",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ae => "AE",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Af => "AF",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ag => "AG",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ai => "AI",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Al => "AL",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Am => "AM",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ao => "AO",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Aq => "AQ",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ar => "AR",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::At => "AT",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Au => "AU",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Aw => "AW",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ax => "AX",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Az => "AZ",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ba => "BA",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Bb => "BB",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Bd => "BD",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Be => "BE",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Bf => "BF",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Bg => "BG",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Bh => "BH",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Bi => "BI",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Bj => "BJ",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Bl => "BL",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Bm => "BM",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Bn => "BN",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Bo => "BO",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Bq => "BQ",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Br => "BR",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Bs => "BS",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Bt => "BT",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Bv => "BV",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Bw => "BW",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::By => "BY",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Bz => "BZ",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ca => "CA",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Cd => "CD",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Cf => "CF",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Cg => "CG",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ch => "CH",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ci => "CI",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ck => "CK",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Cl => "CL",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Cm => "CM",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Cn => "CN",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Co => "CO",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Cr => "CR",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Cv => "CV",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Cw => "CW",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Cy => "CY",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Cz => "CZ",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::De => "DE",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Dj => "DJ",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Dk => "DK",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Dm => "DM",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Do => "DO",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Dz => "DZ",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ec => "EC",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ee => "EE",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Eg => "EG",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Eh => "EH",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Er => "ER",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Es => "ES",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Et => "ET",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Fi => "FI",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Fj => "FJ",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Fk => "FK",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Fo => "FO",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Fr => "FR",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ga => "GA",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Gb => "GB",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Gd => "GD",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ge => "GE",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Gf => "GF",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Gg => "GG",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Gh => "GH",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Gi => "GI",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Gl => "GL",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Gm => "GM",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Gn => "GN",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Gp => "GP",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Gq => "GQ",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Gr => "GR",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Gs => "GS",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Gt => "GT",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Gu => "GU",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Gw => "GW",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Gy => "GY",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Hk => "HK",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Hn => "HN",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Hr => "HR",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ht => "HT",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Hu => "HU",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Id => "ID",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ie => "IE",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Il => "IL",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Im => "IM",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::In => "IN",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Io => "IO",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Iq => "IQ",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Is => "IS",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::It => "IT",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Je => "JE",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Jm => "JM",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Jo => "JO",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Jp => "JP",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ke => "KE",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Kg => "KG",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Kh => "KH",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ki => "KI",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Km => "KM",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Kn => "KN",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Kr => "KR",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Kw => "KW",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ky => "KY",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Kz => "KZ",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::La => "LA",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Lb => "LB",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Lc => "LC",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Li => "LI",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Lk => "LK",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Lr => "LR",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ls => "LS",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Lt => "LT",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Lu => "LU",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Lv => "LV",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ly => "LY",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ma => "MA",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Mc => "MC",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Md => "MD",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Me => "ME",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Mf => "MF",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Mg => "MG",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Mk => "MK",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ml => "ML",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Mm => "MM",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Mn => "MN",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Mo => "MO",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Mq => "MQ",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Mr => "MR",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ms => "MS",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Mt => "MT",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Mu => "MU",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Mv => "MV",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Mw => "MW",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Mx => "MX",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::My => "MY",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Mz => "MZ",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Na => "NA",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Nc => "NC",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ne => "NE",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ng => "NG",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ni => "NI",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Nl => "NL",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::No => "NO",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Np => "NP",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Nr => "NR",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Nu => "NU",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Nz => "NZ",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Om => "OM",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Pa => "PA",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Pe => "PE",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Pf => "PF",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Pg => "PG",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ph => "PH",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Pk => "PK",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Pl => "PL",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Pm => "PM",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Pn => "PN",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Pr => "PR",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ps => "PS",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Pt => "PT",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Py => "PY",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Qa => "QA",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Re => "RE",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ro => "RO",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Rs => "RS",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ru => "RU",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Rw => "RW",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Sa => "SA",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Sb => "SB",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Sc => "SC",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Se => "SE",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Sg => "SG",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Sh => "SH",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Si => "SI",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Sj => "SJ",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Sk => "SK",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Sl => "SL",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Sm => "SM",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Sn => "SN",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::So => "SO",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Sr => "SR",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ss => "SS",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::St => "ST",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Sv => "SV",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Sx => "SX",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Sz => "SZ",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ta => "TA",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Tc => "TC",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Td => "TD",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Tf => "TF",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Tg => "TG",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Th => "TH",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Tj => "TJ",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Tk => "TK",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Tl => "TL",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Tm => "TM",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Tn => "TN",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::To => "TO",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Tr => "TR",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Tt => "TT",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Tv => "TV",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Tw => "TW",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Tz => "TZ",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ua => "UA",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ug => "UG",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Us => "US",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Uy => "UY",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Uz => "UZ",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Va => "VA",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Vc => "VC",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ve => "VE",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Vg => "VG",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Vn => "VN",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Vu => "VU",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Wf => "WF",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ws => "WS",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Xk => "XK",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Ye => "YE",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Yt => "YT",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Za => "ZA",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Zm => "ZM",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Zw => "ZW",
CreatePaymentLinkShippingAddressCollectionAllowedCountries::Zz => "ZZ",
}
}
}
impl AsRef<str> for CreatePaymentLinkShippingAddressCollectionAllowedCountries {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreatePaymentLinkShippingAddressCollectionAllowedCountries {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreatePaymentLinkShippingAddressCollectionAllowedCountries {
fn default() -> Self {
Self::Ac
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreatePaymentLinkSubscriptionDataInvoiceSettingsIssuerType {
Account,
#[serde(rename = "self")]
Self_,
}
impl CreatePaymentLinkSubscriptionDataInvoiceSettingsIssuerType {
pub fn as_str(self) -> &'static str {
match self {
CreatePaymentLinkSubscriptionDataInvoiceSettingsIssuerType::Account => "account",
CreatePaymentLinkSubscriptionDataInvoiceSettingsIssuerType::Self_ => "self",
}
}
}
impl AsRef<str> for CreatePaymentLinkSubscriptionDataInvoiceSettingsIssuerType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreatePaymentLinkSubscriptionDataInvoiceSettingsIssuerType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreatePaymentLinkSubscriptionDataInvoiceSettingsIssuerType {
fn default() -> Self {
Self::Account
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreatePaymentLinkSubscriptionDataTrialSettingsEndBehaviorMissingPaymentMethod {
Cancel,
CreateInvoice,
Pause,
}
impl CreatePaymentLinkSubscriptionDataTrialSettingsEndBehaviorMissingPaymentMethod {
pub fn as_str(self) -> &'static str {
match self {
CreatePaymentLinkSubscriptionDataTrialSettingsEndBehaviorMissingPaymentMethod::Cancel => "cancel",
CreatePaymentLinkSubscriptionDataTrialSettingsEndBehaviorMissingPaymentMethod::CreateInvoice => "create_invoice",
CreatePaymentLinkSubscriptionDataTrialSettingsEndBehaviorMissingPaymentMethod::Pause => "pause",
}
}
}
impl AsRef<str> for CreatePaymentLinkSubscriptionDataTrialSettingsEndBehaviorMissingPaymentMethod {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display
for CreatePaymentLinkSubscriptionDataTrialSettingsEndBehaviorMissingPaymentMethod
{
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CreatePaymentLinkSubscriptionDataTrialSettingsEndBehaviorMissingPaymentMethod
{
fn default() -> Self {
Self::Cancel
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum PaymentLinkBillingAddressCollection {
Auto,
Required,
}
impl PaymentLinkBillingAddressCollection {
pub fn as_str(self) -> &'static str {
match self {
PaymentLinkBillingAddressCollection::Auto => "auto",
PaymentLinkBillingAddressCollection::Required => "required",
}
}
}
impl AsRef<str> for PaymentLinkBillingAddressCollection {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for PaymentLinkBillingAddressCollection {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for PaymentLinkBillingAddressCollection {
fn default() -> Self {
Self::Auto
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum PaymentLinkCustomerCreation {
Always,
IfRequired,
}
impl PaymentLinkCustomerCreation {
pub fn as_str(self) -> &'static str {
match self {
PaymentLinkCustomerCreation::Always => "always",
PaymentLinkCustomerCreation::IfRequired => "if_required",
}
}
}
impl AsRef<str> for PaymentLinkCustomerCreation {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for PaymentLinkCustomerCreation {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for PaymentLinkCustomerCreation {
fn default() -> Self {
Self::Always
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum PaymentLinkPaymentMethodCollection {
Always,
IfRequired,
}
impl PaymentLinkPaymentMethodCollection {
pub fn as_str(self) -> &'static str {
match self {
PaymentLinkPaymentMethodCollection::Always => "always",
PaymentLinkPaymentMethodCollection::IfRequired => "if_required",
}
}
}
impl AsRef<str> for PaymentLinkPaymentMethodCollection {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for PaymentLinkPaymentMethodCollection {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for PaymentLinkPaymentMethodCollection {
fn default() -> Self {
Self::Always
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum PaymentLinkPaymentMethodTypes {
Affirm,
AfterpayClearpay,
Alipay,
AuBecsDebit,
BacsDebit,
Bancontact,
Blik,
Boleto,
Card,
Cashapp,
Eps,
Fpx,
Giropay,
Grabpay,
Ideal,
Klarna,
Konbini,
Link,
Oxxo,
P24,
Paynow,
Paypal,
Pix,
Promptpay,
SepaDebit,
Sofort,
Swish,
UsBankAccount,
WechatPay,
}
impl PaymentLinkPaymentMethodTypes {
pub fn as_str(self) -> &'static str {
match self {
PaymentLinkPaymentMethodTypes::Affirm => "affirm",
PaymentLinkPaymentMethodTypes::AfterpayClearpay => "afterpay_clearpay",
PaymentLinkPaymentMethodTypes::Alipay => "alipay",
PaymentLinkPaymentMethodTypes::AuBecsDebit => "au_becs_debit",
PaymentLinkPaymentMethodTypes::BacsDebit => "bacs_debit",
PaymentLinkPaymentMethodTypes::Bancontact => "bancontact",
PaymentLinkPaymentMethodTypes::Blik => "blik",
PaymentLinkPaymentMethodTypes::Boleto => "boleto",
PaymentLinkPaymentMethodTypes::Card => "card",
PaymentLinkPaymentMethodTypes::Cashapp => "cashapp",
PaymentLinkPaymentMethodTypes::Eps => "eps",
PaymentLinkPaymentMethodTypes::Fpx => "fpx",
PaymentLinkPaymentMethodTypes::Giropay => "giropay",
PaymentLinkPaymentMethodTypes::Grabpay => "grabpay",
PaymentLinkPaymentMethodTypes::Ideal => "ideal",
PaymentLinkPaymentMethodTypes::Klarna => "klarna",
PaymentLinkPaymentMethodTypes::Konbini => "konbini",
PaymentLinkPaymentMethodTypes::Link => "link",
PaymentLinkPaymentMethodTypes::Oxxo => "oxxo",
PaymentLinkPaymentMethodTypes::P24 => "p24",
PaymentLinkPaymentMethodTypes::Paynow => "paynow",
PaymentLinkPaymentMethodTypes::Paypal => "paypal",
PaymentLinkPaymentMethodTypes::Pix => "pix",
PaymentLinkPaymentMethodTypes::Promptpay => "promptpay",
PaymentLinkPaymentMethodTypes::SepaDebit => "sepa_debit",
PaymentLinkPaymentMethodTypes::Sofort => "sofort",
PaymentLinkPaymentMethodTypes::Swish => "swish",
PaymentLinkPaymentMethodTypes::UsBankAccount => "us_bank_account",
PaymentLinkPaymentMethodTypes::WechatPay => "wechat_pay",
}
}
}
impl AsRef<str> for PaymentLinkPaymentMethodTypes {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for PaymentLinkPaymentMethodTypes {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for PaymentLinkPaymentMethodTypes {
fn default() -> Self {
Self::Affirm
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum PaymentLinkSubmitType {
Auto,
Book,
Donate,
Pay,
}
impl PaymentLinkSubmitType {
pub fn as_str(self) -> &'static str {
match self {
PaymentLinkSubmitType::Auto => "auto",
PaymentLinkSubmitType::Book => "book",
PaymentLinkSubmitType::Donate => "donate",
PaymentLinkSubmitType::Pay => "pay",
}
}
}
impl AsRef<str> for PaymentLinkSubmitType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for PaymentLinkSubmitType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for PaymentLinkSubmitType {
fn default() -> Self {
Self::Auto
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum PaymentLinksResourceAfterCompletionType {
HostedConfirmation,
Redirect,
}
impl PaymentLinksResourceAfterCompletionType {
pub fn as_str(self) -> &'static str {
match self {
PaymentLinksResourceAfterCompletionType::HostedConfirmation => "hosted_confirmation",
PaymentLinksResourceAfterCompletionType::Redirect => "redirect",
}
}
}
impl AsRef<str> for PaymentLinksResourceAfterCompletionType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for PaymentLinksResourceAfterCompletionType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for PaymentLinksResourceAfterCompletionType {
fn default() -> Self {
Self::HostedConfirmation
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum PaymentLinksResourceConsentCollectionPromotions {
Auto,
None,
}
impl PaymentLinksResourceConsentCollectionPromotions {
pub fn as_str(self) -> &'static str {
match self {
PaymentLinksResourceConsentCollectionPromotions::Auto => "auto",
PaymentLinksResourceConsentCollectionPromotions::None => "none",
}
}
}
impl AsRef<str> for PaymentLinksResourceConsentCollectionPromotions {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for PaymentLinksResourceConsentCollectionPromotions {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for PaymentLinksResourceConsentCollectionPromotions {
fn default() -> Self {
Self::Auto
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum PaymentLinksResourceConsentCollectionTermsOfService {
None,
Required,
}
impl PaymentLinksResourceConsentCollectionTermsOfService {
pub fn as_str(self) -> &'static str {
match self {
PaymentLinksResourceConsentCollectionTermsOfService::None => "none",
PaymentLinksResourceConsentCollectionTermsOfService::Required => "required",
}
}
}
impl AsRef<str> for PaymentLinksResourceConsentCollectionTermsOfService {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for PaymentLinksResourceConsentCollectionTermsOfService {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for PaymentLinksResourceConsentCollectionTermsOfService {
fn default() -> Self {
Self::None
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum PaymentLinksResourceCustomFieldsLabelType {
Custom,
}
impl PaymentLinksResourceCustomFieldsLabelType {
pub fn as_str(self) -> &'static str {
match self {
PaymentLinksResourceCustomFieldsLabelType::Custom => "custom",
}
}
}
impl AsRef<str> for PaymentLinksResourceCustomFieldsLabelType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for PaymentLinksResourceCustomFieldsLabelType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for PaymentLinksResourceCustomFieldsLabelType {
fn default() -> Self {
Self::Custom
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum PaymentLinksResourceCustomFieldsType {
Dropdown,
Numeric,
Text,
}
impl PaymentLinksResourceCustomFieldsType {
pub fn as_str(self) -> &'static str {
match self {
PaymentLinksResourceCustomFieldsType::Dropdown => "dropdown",
PaymentLinksResourceCustomFieldsType::Numeric => "numeric",
PaymentLinksResourceCustomFieldsType::Text => "text",
}
}
}
impl AsRef<str> for PaymentLinksResourceCustomFieldsType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for PaymentLinksResourceCustomFieldsType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for PaymentLinksResourceCustomFieldsType {
fn default() -> Self {
Self::Dropdown
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum PaymentLinksResourcePaymentIntentDataCaptureMethod {
Automatic,
AutomaticAsync,
Manual,
}
impl PaymentLinksResourcePaymentIntentDataCaptureMethod {
pub fn as_str(self) -> &'static str {
match self {
PaymentLinksResourcePaymentIntentDataCaptureMethod::Automatic => "automatic",
PaymentLinksResourcePaymentIntentDataCaptureMethod::AutomaticAsync => "automatic_async",
PaymentLinksResourcePaymentIntentDataCaptureMethod::Manual => "manual",
}
}
}
impl AsRef<str> for PaymentLinksResourcePaymentIntentDataCaptureMethod {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for PaymentLinksResourcePaymentIntentDataCaptureMethod {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for PaymentLinksResourcePaymentIntentDataCaptureMethod {
fn default() -> Self {
Self::Automatic
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum PaymentLinksResourcePaymentIntentDataSetupFutureUsage {
OffSession,
OnSession,
}
impl PaymentLinksResourcePaymentIntentDataSetupFutureUsage {
pub fn as_str(self) -> &'static str {
match self {
PaymentLinksResourcePaymentIntentDataSetupFutureUsage::OffSession => "off_session",
PaymentLinksResourcePaymentIntentDataSetupFutureUsage::OnSession => "on_session",
}
}
}
impl AsRef<str> for PaymentLinksResourcePaymentIntentDataSetupFutureUsage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for PaymentLinksResourcePaymentIntentDataSetupFutureUsage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for PaymentLinksResourcePaymentIntentDataSetupFutureUsage {
fn default() -> Self {
Self::OffSession
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum PaymentLinksResourcePaymentMethodReuseAgreementPosition {
Auto,
Hidden,
}
impl PaymentLinksResourcePaymentMethodReuseAgreementPosition {
pub fn as_str(self) -> &'static str {
match self {
PaymentLinksResourcePaymentMethodReuseAgreementPosition::Auto => "auto",
PaymentLinksResourcePaymentMethodReuseAgreementPosition::Hidden => "hidden",
}
}
}
impl AsRef<str> for PaymentLinksResourcePaymentMethodReuseAgreementPosition {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for PaymentLinksResourcePaymentMethodReuseAgreementPosition {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for PaymentLinksResourcePaymentMethodReuseAgreementPosition {
fn default() -> Self {
Self::Auto
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum PaymentLinksResourceShippingAddressCollectionAllowedCountries {
#[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 PaymentLinksResourceShippingAddressCollectionAllowedCountries {
pub fn as_str(self) -> &'static str {
match self {
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ac => "AC",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ad => "AD",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ae => "AE",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Af => "AF",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ag => "AG",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ai => "AI",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Al => "AL",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Am => "AM",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ao => "AO",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Aq => "AQ",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ar => "AR",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::At => "AT",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Au => "AU",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Aw => "AW",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ax => "AX",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Az => "AZ",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ba => "BA",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Bb => "BB",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Bd => "BD",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Be => "BE",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Bf => "BF",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Bg => "BG",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Bh => "BH",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Bi => "BI",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Bj => "BJ",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Bl => "BL",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Bm => "BM",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Bn => "BN",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Bo => "BO",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Bq => "BQ",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Br => "BR",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Bs => "BS",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Bt => "BT",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Bv => "BV",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Bw => "BW",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::By => "BY",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Bz => "BZ",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ca => "CA",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Cd => "CD",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Cf => "CF",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Cg => "CG",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ch => "CH",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ci => "CI",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ck => "CK",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Cl => "CL",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Cm => "CM",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Cn => "CN",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Co => "CO",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Cr => "CR",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Cv => "CV",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Cw => "CW",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Cy => "CY",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Cz => "CZ",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::De => "DE",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Dj => "DJ",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Dk => "DK",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Dm => "DM",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Do => "DO",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Dz => "DZ",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ec => "EC",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ee => "EE",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Eg => "EG",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Eh => "EH",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Er => "ER",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Es => "ES",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Et => "ET",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Fi => "FI",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Fj => "FJ",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Fk => "FK",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Fo => "FO",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Fr => "FR",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ga => "GA",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Gb => "GB",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Gd => "GD",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ge => "GE",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Gf => "GF",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Gg => "GG",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Gh => "GH",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Gi => "GI",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Gl => "GL",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Gm => "GM",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Gn => "GN",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Gp => "GP",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Gq => "GQ",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Gr => "GR",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Gs => "GS",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Gt => "GT",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Gu => "GU",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Gw => "GW",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Gy => "GY",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Hk => "HK",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Hn => "HN",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Hr => "HR",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ht => "HT",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Hu => "HU",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Id => "ID",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ie => "IE",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Il => "IL",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Im => "IM",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::In => "IN",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Io => "IO",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Iq => "IQ",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Is => "IS",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::It => "IT",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Je => "JE",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Jm => "JM",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Jo => "JO",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Jp => "JP",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ke => "KE",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Kg => "KG",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Kh => "KH",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ki => "KI",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Km => "KM",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Kn => "KN",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Kr => "KR",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Kw => "KW",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ky => "KY",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Kz => "KZ",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::La => "LA",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Lb => "LB",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Lc => "LC",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Li => "LI",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Lk => "LK",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Lr => "LR",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ls => "LS",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Lt => "LT",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Lu => "LU",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Lv => "LV",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ly => "LY",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ma => "MA",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Mc => "MC",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Md => "MD",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Me => "ME",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Mf => "MF",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Mg => "MG",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Mk => "MK",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ml => "ML",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Mm => "MM",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Mn => "MN",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Mo => "MO",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Mq => "MQ",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Mr => "MR",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ms => "MS",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Mt => "MT",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Mu => "MU",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Mv => "MV",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Mw => "MW",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Mx => "MX",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::My => "MY",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Mz => "MZ",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Na => "NA",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Nc => "NC",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ne => "NE",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ng => "NG",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ni => "NI",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Nl => "NL",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::No => "NO",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Np => "NP",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Nr => "NR",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Nu => "NU",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Nz => "NZ",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Om => "OM",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Pa => "PA",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Pe => "PE",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Pf => "PF",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Pg => "PG",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ph => "PH",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Pk => "PK",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Pl => "PL",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Pm => "PM",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Pn => "PN",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Pr => "PR",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ps => "PS",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Pt => "PT",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Py => "PY",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Qa => "QA",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Re => "RE",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ro => "RO",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Rs => "RS",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ru => "RU",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Rw => "RW",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Sa => "SA",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Sb => "SB",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Sc => "SC",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Se => "SE",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Sg => "SG",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Sh => "SH",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Si => "SI",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Sj => "SJ",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Sk => "SK",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Sl => "SL",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Sm => "SM",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Sn => "SN",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::So => "SO",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Sr => "SR",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ss => "SS",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::St => "ST",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Sv => "SV",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Sx => "SX",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Sz => "SZ",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ta => "TA",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Tc => "TC",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Td => "TD",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Tf => "TF",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Tg => "TG",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Th => "TH",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Tj => "TJ",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Tk => "TK",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Tl => "TL",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Tm => "TM",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Tn => "TN",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::To => "TO",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Tr => "TR",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Tt => "TT",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Tv => "TV",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Tw => "TW",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Tz => "TZ",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ua => "UA",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ug => "UG",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Us => "US",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Uy => "UY",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Uz => "UZ",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Va => "VA",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Vc => "VC",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ve => "VE",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Vg => "VG",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Vn => "VN",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Vu => "VU",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Wf => "WF",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ws => "WS",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Xk => "XK",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Ye => "YE",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Yt => "YT",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Za => "ZA",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Zm => "ZM",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Zw => "ZW",
PaymentLinksResourceShippingAddressCollectionAllowedCountries::Zz => "ZZ",
}
}
}
impl AsRef<str> for PaymentLinksResourceShippingAddressCollectionAllowedCountries {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for PaymentLinksResourceShippingAddressCollectionAllowedCountries {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for PaymentLinksResourceShippingAddressCollectionAllowedCountries {
fn default() -> Self {
Self::Ac
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum UpdatePaymentLinkAfterCompletionType {
HostedConfirmation,
Redirect,
}
impl UpdatePaymentLinkAfterCompletionType {
pub fn as_str(self) -> &'static str {
match self {
UpdatePaymentLinkAfterCompletionType::HostedConfirmation => "hosted_confirmation",
UpdatePaymentLinkAfterCompletionType::Redirect => "redirect",
}
}
}
impl AsRef<str> for UpdatePaymentLinkAfterCompletionType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for UpdatePaymentLinkAfterCompletionType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for UpdatePaymentLinkAfterCompletionType {
fn default() -> Self {
Self::HostedConfirmation
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum UpdatePaymentLinkAutomaticTaxLiabilityType {
Account,
#[serde(rename = "self")]
Self_,
}
impl UpdatePaymentLinkAutomaticTaxLiabilityType {
pub fn as_str(self) -> &'static str {
match self {
UpdatePaymentLinkAutomaticTaxLiabilityType::Account => "account",
UpdatePaymentLinkAutomaticTaxLiabilityType::Self_ => "self",
}
}
}
impl AsRef<str> for UpdatePaymentLinkAutomaticTaxLiabilityType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for UpdatePaymentLinkAutomaticTaxLiabilityType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for UpdatePaymentLinkAutomaticTaxLiabilityType {
fn default() -> Self {
Self::Account
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum UpdatePaymentLinkCustomFieldsLabelType {
Custom,
}
impl UpdatePaymentLinkCustomFieldsLabelType {
pub fn as_str(self) -> &'static str {
match self {
UpdatePaymentLinkCustomFieldsLabelType::Custom => "custom",
}
}
}
impl AsRef<str> for UpdatePaymentLinkCustomFieldsLabelType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for UpdatePaymentLinkCustomFieldsLabelType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for UpdatePaymentLinkCustomFieldsLabelType {
fn default() -> Self {
Self::Custom
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum UpdatePaymentLinkCustomFieldsType {
Dropdown,
Numeric,
Text,
}
impl UpdatePaymentLinkCustomFieldsType {
pub fn as_str(self) -> &'static str {
match self {
UpdatePaymentLinkCustomFieldsType::Dropdown => "dropdown",
UpdatePaymentLinkCustomFieldsType::Numeric => "numeric",
UpdatePaymentLinkCustomFieldsType::Text => "text",
}
}
}
impl AsRef<str> for UpdatePaymentLinkCustomFieldsType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for UpdatePaymentLinkCustomFieldsType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for UpdatePaymentLinkCustomFieldsType {
fn default() -> Self {
Self::Dropdown
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum UpdatePaymentLinkInvoiceCreationInvoiceDataIssuerType {
Account,
#[serde(rename = "self")]
Self_,
}
impl UpdatePaymentLinkInvoiceCreationInvoiceDataIssuerType {
pub fn as_str(self) -> &'static str {
match self {
UpdatePaymentLinkInvoiceCreationInvoiceDataIssuerType::Account => "account",
UpdatePaymentLinkInvoiceCreationInvoiceDataIssuerType::Self_ => "self",
}
}
}
impl AsRef<str> for UpdatePaymentLinkInvoiceCreationInvoiceDataIssuerType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for UpdatePaymentLinkInvoiceCreationInvoiceDataIssuerType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for UpdatePaymentLinkInvoiceCreationInvoiceDataIssuerType {
fn default() -> Self {
Self::Account
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum UpdatePaymentLinkInvoiceCreationInvoiceDataRenderingOptionsAmountTaxDisplay {
ExcludeTax,
IncludeInclusiveTax,
}
impl UpdatePaymentLinkInvoiceCreationInvoiceDataRenderingOptionsAmountTaxDisplay {
pub fn as_str(self) -> &'static str {
match self {
UpdatePaymentLinkInvoiceCreationInvoiceDataRenderingOptionsAmountTaxDisplay::ExcludeTax => "exclude_tax",
UpdatePaymentLinkInvoiceCreationInvoiceDataRenderingOptionsAmountTaxDisplay::IncludeInclusiveTax => "include_inclusive_tax",
}
}
}
impl AsRef<str> for UpdatePaymentLinkInvoiceCreationInvoiceDataRenderingOptionsAmountTaxDisplay {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display
for UpdatePaymentLinkInvoiceCreationInvoiceDataRenderingOptionsAmountTaxDisplay
{
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for UpdatePaymentLinkInvoiceCreationInvoiceDataRenderingOptionsAmountTaxDisplay
{
fn default() -> Self {
Self::ExcludeTax
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum UpdatePaymentLinkPaymentMethodTypes {
Affirm,
AfterpayClearpay,
Alipay,
AuBecsDebit,
BacsDebit,
Bancontact,
Blik,
Boleto,
Card,
Cashapp,
Eps,
Fpx,
Giropay,
Grabpay,
Ideal,
Klarna,
Konbini,
Link,
Oxxo,
P24,
Paynow,
Paypal,
Pix,
Promptpay,
SepaDebit,
Sofort,
Swish,
UsBankAccount,
WechatPay,
}
impl UpdatePaymentLinkPaymentMethodTypes {
pub fn as_str(self) -> &'static str {
match self {
UpdatePaymentLinkPaymentMethodTypes::Affirm => "affirm",
UpdatePaymentLinkPaymentMethodTypes::AfterpayClearpay => "afterpay_clearpay",
UpdatePaymentLinkPaymentMethodTypes::Alipay => "alipay",
UpdatePaymentLinkPaymentMethodTypes::AuBecsDebit => "au_becs_debit",
UpdatePaymentLinkPaymentMethodTypes::BacsDebit => "bacs_debit",
UpdatePaymentLinkPaymentMethodTypes::Bancontact => "bancontact",
UpdatePaymentLinkPaymentMethodTypes::Blik => "blik",
UpdatePaymentLinkPaymentMethodTypes::Boleto => "boleto",
UpdatePaymentLinkPaymentMethodTypes::Card => "card",
UpdatePaymentLinkPaymentMethodTypes::Cashapp => "cashapp",
UpdatePaymentLinkPaymentMethodTypes::Eps => "eps",
UpdatePaymentLinkPaymentMethodTypes::Fpx => "fpx",
UpdatePaymentLinkPaymentMethodTypes::Giropay => "giropay",
UpdatePaymentLinkPaymentMethodTypes::Grabpay => "grabpay",
UpdatePaymentLinkPaymentMethodTypes::Ideal => "ideal",
UpdatePaymentLinkPaymentMethodTypes::Klarna => "klarna",
UpdatePaymentLinkPaymentMethodTypes::Konbini => "konbini",
UpdatePaymentLinkPaymentMethodTypes::Link => "link",
UpdatePaymentLinkPaymentMethodTypes::Oxxo => "oxxo",
UpdatePaymentLinkPaymentMethodTypes::P24 => "p24",
UpdatePaymentLinkPaymentMethodTypes::Paynow => "paynow",
UpdatePaymentLinkPaymentMethodTypes::Paypal => "paypal",
UpdatePaymentLinkPaymentMethodTypes::Pix => "pix",
UpdatePaymentLinkPaymentMethodTypes::Promptpay => "promptpay",
UpdatePaymentLinkPaymentMethodTypes::SepaDebit => "sepa_debit",
UpdatePaymentLinkPaymentMethodTypes::Sofort => "sofort",
UpdatePaymentLinkPaymentMethodTypes::Swish => "swish",
UpdatePaymentLinkPaymentMethodTypes::UsBankAccount => "us_bank_account",
UpdatePaymentLinkPaymentMethodTypes::WechatPay => "wechat_pay",
}
}
}
impl AsRef<str> for UpdatePaymentLinkPaymentMethodTypes {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for UpdatePaymentLinkPaymentMethodTypes {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for UpdatePaymentLinkPaymentMethodTypes {
fn default() -> Self {
Self::Affirm
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum UpdatePaymentLinkShippingAddressCollectionAllowedCountries {
#[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 UpdatePaymentLinkShippingAddressCollectionAllowedCountries {
pub fn as_str(self) -> &'static str {
match self {
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ac => "AC",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ad => "AD",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ae => "AE",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Af => "AF",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ag => "AG",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ai => "AI",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Al => "AL",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Am => "AM",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ao => "AO",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Aq => "AQ",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ar => "AR",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::At => "AT",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Au => "AU",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Aw => "AW",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ax => "AX",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Az => "AZ",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ba => "BA",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Bb => "BB",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Bd => "BD",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Be => "BE",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Bf => "BF",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Bg => "BG",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Bh => "BH",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Bi => "BI",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Bj => "BJ",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Bl => "BL",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Bm => "BM",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Bn => "BN",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Bo => "BO",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Bq => "BQ",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Br => "BR",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Bs => "BS",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Bt => "BT",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Bv => "BV",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Bw => "BW",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::By => "BY",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Bz => "BZ",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ca => "CA",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Cd => "CD",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Cf => "CF",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Cg => "CG",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ch => "CH",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ci => "CI",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ck => "CK",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Cl => "CL",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Cm => "CM",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Cn => "CN",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Co => "CO",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Cr => "CR",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Cv => "CV",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Cw => "CW",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Cy => "CY",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Cz => "CZ",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::De => "DE",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Dj => "DJ",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Dk => "DK",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Dm => "DM",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Do => "DO",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Dz => "DZ",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ec => "EC",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ee => "EE",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Eg => "EG",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Eh => "EH",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Er => "ER",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Es => "ES",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Et => "ET",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Fi => "FI",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Fj => "FJ",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Fk => "FK",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Fo => "FO",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Fr => "FR",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ga => "GA",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Gb => "GB",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Gd => "GD",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ge => "GE",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Gf => "GF",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Gg => "GG",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Gh => "GH",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Gi => "GI",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Gl => "GL",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Gm => "GM",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Gn => "GN",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Gp => "GP",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Gq => "GQ",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Gr => "GR",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Gs => "GS",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Gt => "GT",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Gu => "GU",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Gw => "GW",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Gy => "GY",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Hk => "HK",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Hn => "HN",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Hr => "HR",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ht => "HT",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Hu => "HU",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Id => "ID",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ie => "IE",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Il => "IL",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Im => "IM",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::In => "IN",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Io => "IO",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Iq => "IQ",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Is => "IS",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::It => "IT",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Je => "JE",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Jm => "JM",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Jo => "JO",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Jp => "JP",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ke => "KE",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Kg => "KG",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Kh => "KH",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ki => "KI",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Km => "KM",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Kn => "KN",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Kr => "KR",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Kw => "KW",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ky => "KY",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Kz => "KZ",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::La => "LA",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Lb => "LB",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Lc => "LC",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Li => "LI",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Lk => "LK",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Lr => "LR",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ls => "LS",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Lt => "LT",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Lu => "LU",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Lv => "LV",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ly => "LY",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ma => "MA",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Mc => "MC",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Md => "MD",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Me => "ME",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Mf => "MF",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Mg => "MG",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Mk => "MK",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ml => "ML",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Mm => "MM",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Mn => "MN",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Mo => "MO",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Mq => "MQ",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Mr => "MR",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ms => "MS",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Mt => "MT",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Mu => "MU",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Mv => "MV",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Mw => "MW",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Mx => "MX",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::My => "MY",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Mz => "MZ",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Na => "NA",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Nc => "NC",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ne => "NE",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ng => "NG",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ni => "NI",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Nl => "NL",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::No => "NO",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Np => "NP",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Nr => "NR",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Nu => "NU",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Nz => "NZ",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Om => "OM",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Pa => "PA",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Pe => "PE",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Pf => "PF",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Pg => "PG",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ph => "PH",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Pk => "PK",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Pl => "PL",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Pm => "PM",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Pn => "PN",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Pr => "PR",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ps => "PS",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Pt => "PT",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Py => "PY",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Qa => "QA",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Re => "RE",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ro => "RO",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Rs => "RS",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ru => "RU",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Rw => "RW",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Sa => "SA",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Sb => "SB",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Sc => "SC",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Se => "SE",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Sg => "SG",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Sh => "SH",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Si => "SI",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Sj => "SJ",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Sk => "SK",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Sl => "SL",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Sm => "SM",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Sn => "SN",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::So => "SO",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Sr => "SR",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ss => "SS",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::St => "ST",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Sv => "SV",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Sx => "SX",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Sz => "SZ",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ta => "TA",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Tc => "TC",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Td => "TD",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Tf => "TF",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Tg => "TG",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Th => "TH",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Tj => "TJ",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Tk => "TK",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Tl => "TL",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Tm => "TM",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Tn => "TN",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::To => "TO",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Tr => "TR",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Tt => "TT",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Tv => "TV",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Tw => "TW",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Tz => "TZ",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ua => "UA",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ug => "UG",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Us => "US",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Uy => "UY",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Uz => "UZ",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Va => "VA",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Vc => "VC",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ve => "VE",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Vg => "VG",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Vn => "VN",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Vu => "VU",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Wf => "WF",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ws => "WS",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Xk => "XK",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Ye => "YE",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Yt => "YT",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Za => "ZA",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Zm => "ZM",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Zw => "ZW",
UpdatePaymentLinkShippingAddressCollectionAllowedCountries::Zz => "ZZ",
}
}
}
impl AsRef<str> for UpdatePaymentLinkShippingAddressCollectionAllowedCountries {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for UpdatePaymentLinkShippingAddressCollectionAllowedCountries {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for UpdatePaymentLinkShippingAddressCollectionAllowedCountries {
fn default() -> Self {
Self::Ac
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum UpdatePaymentLinkSubscriptionDataInvoiceSettingsIssuerType {
Account,
#[serde(rename = "self")]
Self_,
}
impl UpdatePaymentLinkSubscriptionDataInvoiceSettingsIssuerType {
pub fn as_str(self) -> &'static str {
match self {
UpdatePaymentLinkSubscriptionDataInvoiceSettingsIssuerType::Account => "account",
UpdatePaymentLinkSubscriptionDataInvoiceSettingsIssuerType::Self_ => "self",
}
}
}
impl AsRef<str> for UpdatePaymentLinkSubscriptionDataInvoiceSettingsIssuerType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for UpdatePaymentLinkSubscriptionDataInvoiceSettingsIssuerType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for UpdatePaymentLinkSubscriptionDataInvoiceSettingsIssuerType {
fn default() -> Self {
Self::Account
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum UpdatePaymentLinkSubscriptionDataTrialSettingsEndBehaviorMissingPaymentMethod {
Cancel,
CreateInvoice,
Pause,
}
impl UpdatePaymentLinkSubscriptionDataTrialSettingsEndBehaviorMissingPaymentMethod {
pub fn as_str(self) -> &'static str {
match self {
UpdatePaymentLinkSubscriptionDataTrialSettingsEndBehaviorMissingPaymentMethod::Cancel => "cancel",
UpdatePaymentLinkSubscriptionDataTrialSettingsEndBehaviorMissingPaymentMethod::CreateInvoice => "create_invoice",
UpdatePaymentLinkSubscriptionDataTrialSettingsEndBehaviorMissingPaymentMethod::Pause => "pause",
}
}
}
impl AsRef<str> for UpdatePaymentLinkSubscriptionDataTrialSettingsEndBehaviorMissingPaymentMethod {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display
for UpdatePaymentLinkSubscriptionDataTrialSettingsEndBehaviorMissingPaymentMethod
{
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for UpdatePaymentLinkSubscriptionDataTrialSettingsEndBehaviorMissingPaymentMethod
{
fn default() -> Self {
Self::Cancel
}
}