use serde::{Deserialize, Serialize};
use crate::client::{Client, Response};
use crate::ids::{CustomerId, InvoiceId, SubscriptionId};
use crate::params::{
CurrencyMap, Deleted, Expand, Expandable, List, Metadata, Object, Paginable, RangeQuery,
Timestamp,
};
use crate::resources::{
Account, Address, ApiErrors, Application, Charge, ConnectAccountReference, Currency, Customer,
Discount, InvoiceLineItem, InvoicePaymentMethodOptionsAcssDebit,
InvoicePaymentMethodOptionsBancontact, InvoicePaymentMethodOptionsCustomerBalance,
InvoicePaymentMethodOptionsKonbini, InvoicePaymentMethodOptionsUsBankAccount,
InvoiceSettingRenderingOptions, InvoicesShippingCost, PaymentIntent, PaymentMethod,
PaymentSource, Quote, Shipping, Subscription, TaxId, TaxRate, TestHelpersTestClock,
};
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct Invoice {
#[serde(default = "InvoiceId::none")]
pub id: InvoiceId,
#[serde(skip_serializing_if = "Option::is_none")]
pub account_country: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub account_name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub account_tax_ids: Option<Vec<Expandable<TaxId>>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub amount_due: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub amount_paid: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub amount_remaining: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub amount_shipping: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub application: Option<Expandable<Application>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub application_fee_amount: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub attempt_count: Option<u64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub attempted: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_advance: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub automatic_tax: Option<AutomaticTax>,
#[serde(skip_serializing_if = "Option::is_none")]
pub billing_reason: Option<InvoiceBillingReason>,
#[serde(skip_serializing_if = "Option::is_none")]
pub charge: Option<Expandable<Charge>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub collection_method: Option<CollectionMethod>,
#[serde(skip_serializing_if = "Option::is_none")]
pub created: Option<Timestamp>,
#[serde(skip_serializing_if = "Option::is_none")]
pub currency: Option<Currency>,
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_fields: Option<Vec<InvoiceSettingCustomField>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub customer: Option<Expandable<Customer>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_address: Option<Address>,
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_email: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_phone: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_shipping: Option<Shipping>,
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_tax_exempt: Option<InvoiceCustomerTaxExempt>,
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_tax_ids: Option<Vec<InvoicesResourceInvoiceTaxId>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub default_payment_method: Option<Expandable<PaymentMethod>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub default_source: Option<Expandable<PaymentSource>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub default_tax_rates: Option<Vec<TaxRate>>,
#[serde(default)]
pub deleted: bool,
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub discount: Option<Discount>,
#[serde(skip_serializing_if = "Option::is_none")]
pub discounts: Option<Vec<Expandable<Discount>>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub due_date: Option<Timestamp>,
#[serde(skip_serializing_if = "Option::is_none")]
pub effective_at: Option<Timestamp>,
#[serde(skip_serializing_if = "Option::is_none")]
pub ending_balance: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub footer: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub from_invoice: Option<InvoicesFromInvoice>,
#[serde(skip_serializing_if = "Option::is_none")]
pub hosted_invoice_url: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub invoice_pdf: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub issuer: Option<ConnectAccountReference>,
#[serde(skip_serializing_if = "Option::is_none")]
pub last_finalization_error: Option<Box<ApiErrors>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_revision: Option<Expandable<Invoice>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub lines: Option<List<InvoiceLineItem>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub livemode: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata: Option<Metadata>,
#[serde(skip_serializing_if = "Option::is_none")]
pub next_payment_attempt: Option<Timestamp>,
#[serde(skip_serializing_if = "Option::is_none")]
pub number: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub on_behalf_of: Option<Expandable<Account>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub paid: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub paid_out_of_band: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_intent: Option<Expandable<PaymentIntent>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_settings: Option<InvoicesPaymentSettings>,
#[serde(skip_serializing_if = "Option::is_none")]
pub period_end: Option<Timestamp>,
#[serde(skip_serializing_if = "Option::is_none")]
pub period_start: Option<Timestamp>,
#[serde(skip_serializing_if = "Option::is_none")]
pub post_payment_credit_notes_amount: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub pre_payment_credit_notes_amount: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub quote: Option<Expandable<Quote>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub receipt_number: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub rendering: Option<InvoicesInvoiceRendering>,
#[serde(skip_serializing_if = "Option::is_none")]
pub rendering_options: Option<InvoiceSettingRenderingOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub shipping_cost: Option<InvoicesShippingCost>,
#[serde(skip_serializing_if = "Option::is_none")]
pub shipping_details: Option<Shipping>,
#[serde(skip_serializing_if = "Option::is_none")]
pub starting_balance: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub statement_descriptor: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<InvoiceStatus>,
#[serde(skip_serializing_if = "Option::is_none")]
pub status_transitions: Option<InvoicesStatusTransitions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub subscription: Option<Expandable<Subscription>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub subscription_details: Option<SubscriptionDetailsData>,
#[serde(skip_serializing_if = "Option::is_none")]
pub subscription_proration_date: Option<Timestamp>,
#[serde(skip_serializing_if = "Option::is_none")]
pub subtotal: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub subtotal_excluding_tax: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tax: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub test_clock: Option<Expandable<TestHelpersTestClock>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub threshold_reason: Option<InvoiceThresholdReason>,
#[serde(skip_serializing_if = "Option::is_none")]
pub total: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub total_discount_amounts: Option<Vec<DiscountsResourceDiscountAmount>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub total_excluding_tax: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub total_tax_amounts: Option<Vec<TaxAmount>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub transfer_data: Option<InvoiceTransferData>,
#[serde(skip_serializing_if = "Option::is_none")]
pub webhooks_delivered_at: Option<Timestamp>,
}
impl Invoice {
pub fn list(client: &Client, params: &ListInvoices<'_>) -> Response<List<Invoice>> {
client.get_query("/invoices", params)
}
pub fn create(client: &Client, params: CreateInvoice<'_>) -> Response<Invoice> {
#[allow(clippy::needless_borrows_for_generic_args)]
client.post_form("/invoices", ¶ms)
}
pub fn retrieve(client: &Client, id: &InvoiceId, expand: &[&str]) -> Response<Invoice> {
client.get_query(&format!("/invoices/{}", id), Expand { expand })
}
pub fn delete(client: &Client, id: &InvoiceId) -> Response<Deleted<InvoiceId>> {
client.delete(&format!("/invoices/{}", id))
}
}
impl Object for Invoice {
type Id = InvoiceId;
fn id(&self) -> Self::Id {
self.id.clone()
}
fn object(&self) -> &'static str {
"invoice"
}
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct AutomaticTax {
pub enabled: bool,
pub liability: Option<ConnectAccountReference>,
pub status: Option<AutomaticTaxStatus>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct DiscountsResourceDiscountAmount {
pub amount: i64,
pub discount: Expandable<Discount>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct InvoiceSettingCustomField {
pub name: String,
pub value: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct TaxAmount {
pub amount: i64,
pub inclusive: bool,
pub tax_rate: Expandable<TaxRate>,
pub taxability_reason: Option<TaxAmountTaxabilityReason>,
pub taxable_amount: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct InvoiceThresholdReason {
pub amount_gte: Option<i64>,
pub item_reasons: Vec<InvoiceItemThresholdReason>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct InvoiceItemThresholdReason {
pub line_item_ids: Vec<String>,
pub usage_gte: i64,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct InvoiceTransferData {
pub amount: Option<i64>,
pub destination: Expandable<Account>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct InvoicesFromInvoice {
pub action: String,
pub invoice: Expandable<Invoice>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct InvoicesInvoiceRendering {
pub amount_tax_display: Option<String>,
pub pdf: Option<InvoiceRenderingPdf>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct InvoiceRenderingPdf {
pub page_size: Option<InvoiceRenderingPdfPageSize>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct InvoicesPaymentSettings {
pub default_mandate: Option<String>,
pub payment_method_options: Option<InvoicesPaymentMethodOptions>,
pub payment_method_types: Option<Vec<InvoicesPaymentSettingsPaymentMethodTypes>>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct InvoicesPaymentMethodOptions {
pub acss_debit: Option<InvoicePaymentMethodOptionsAcssDebit>,
pub bancontact: Option<InvoicePaymentMethodOptionsBancontact>,
pub card: Option<InvoicePaymentMethodOptionsCard>,
pub customer_balance: Option<InvoicePaymentMethodOptionsCustomerBalance>,
pub konbini: Option<InvoicePaymentMethodOptionsKonbini>,
pub us_bank_account: Option<InvoicePaymentMethodOptionsUsBankAccount>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct InvoicePaymentMethodOptionsCard {
#[serde(skip_serializing_if = "Option::is_none")]
pub installments: Option<InvoiceInstallmentsCard>,
pub request_three_d_secure: Option<InvoicePaymentMethodOptionsCardRequestThreeDSecure>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct InvoiceInstallmentsCard {
pub enabled: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct InvoicesResourceInvoiceTaxId {
#[serde(rename = "type")]
pub type_: TaxIdType,
pub value: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct InvoicesStatusTransitions {
pub finalized_at: Option<Timestamp>,
pub marked_uncollectible_at: Option<Timestamp>,
pub paid_at: Option<Timestamp>,
pub voided_at: Option<Timestamp>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct SubscriptionDetailsData {
pub metadata: Option<Metadata>,
}
#[derive(Clone, Debug, Serialize, Default)]
pub struct CreateInvoice<'a> {
#[serde(skip_serializing_if = "Option::is_none")]
pub account_tax_ids: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub application_fee_amount: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_advance: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub automatic_tax: Option<CreateInvoiceAutomaticTax>,
#[serde(skip_serializing_if = "Option::is_none")]
pub collection_method: Option<CollectionMethod>,
#[serde(skip_serializing_if = "Option::is_none")]
pub currency: Option<Currency>,
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_fields: Option<Vec<CreateInvoiceCustomFields>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub customer: Option<CustomerId>,
#[serde(skip_serializing_if = "Option::is_none")]
pub days_until_due: Option<u32>,
#[serde(skip_serializing_if = "Option::is_none")]
pub default_payment_method: Option<&'a str>,
#[serde(skip_serializing_if = "Option::is_none")]
pub default_source: Option<&'a str>,
#[serde(skip_serializing_if = "Option::is_none")]
pub default_tax_rates: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<&'a str>,
#[serde(skip_serializing_if = "Option::is_none")]
pub discounts: Option<Vec<CreateInvoiceDiscounts>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub due_date: Option<Timestamp>,
#[serde(skip_serializing_if = "Option::is_none")]
pub effective_at: Option<Timestamp>,
#[serde(skip_serializing_if = "Expand::is_empty")]
pub expand: &'a [&'a str],
#[serde(skip_serializing_if = "Option::is_none")]
pub footer: Option<&'a str>,
#[serde(skip_serializing_if = "Option::is_none")]
pub from_invoice: Option<CreateInvoiceFromInvoice>,
#[serde(skip_serializing_if = "Option::is_none")]
pub issuer: Option<CreateInvoiceIssuer>,
#[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_settings: Option<CreateInvoicePaymentSettings>,
#[serde(skip_serializing_if = "Option::is_none")]
pub pending_invoice_items_behavior: Option<InvoicePendingInvoiceItemsBehavior>,
#[serde(skip_serializing_if = "Option::is_none")]
pub rendering: Option<CreateInvoiceRendering>,
#[serde(skip_serializing_if = "Option::is_none")]
pub rendering_options: Option<CreateInvoiceRenderingOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub shipping_cost: Option<CreateInvoiceShippingCost>,
#[serde(skip_serializing_if = "Option::is_none")]
pub shipping_details: Option<CreateInvoiceShippingDetails>,
#[serde(skip_serializing_if = "Option::is_none")]
pub statement_descriptor: Option<&'a str>,
#[serde(skip_serializing_if = "Option::is_none")]
pub subscription: Option<SubscriptionId>,
#[serde(skip_serializing_if = "Option::is_none")]
pub transfer_data: Option<CreateInvoiceTransferData>,
}
impl<'a> CreateInvoice<'a> {
pub fn new() -> Self {
CreateInvoice {
account_tax_ids: Default::default(),
application_fee_amount: Default::default(),
auto_advance: Default::default(),
automatic_tax: Default::default(),
collection_method: Default::default(),
currency: Default::default(),
custom_fields: Default::default(),
customer: Default::default(),
days_until_due: Default::default(),
default_payment_method: Default::default(),
default_source: Default::default(),
default_tax_rates: Default::default(),
description: Default::default(),
discounts: Default::default(),
due_date: Default::default(),
effective_at: Default::default(),
expand: Default::default(),
footer: Default::default(),
from_invoice: Default::default(),
issuer: Default::default(),
metadata: Default::default(),
on_behalf_of: Default::default(),
payment_settings: Default::default(),
pending_invoice_items_behavior: Default::default(),
rendering: Default::default(),
rendering_options: Default::default(),
shipping_cost: Default::default(),
shipping_details: Default::default(),
statement_descriptor: Default::default(),
subscription: Default::default(),
transfer_data: Default::default(),
}
}
}
#[derive(Clone, Debug, Serialize, Default)]
pub struct ListInvoices<'a> {
#[serde(skip_serializing_if = "Option::is_none")]
pub collection_method: Option<CollectionMethod>,
#[serde(skip_serializing_if = "Option::is_none")]
pub created: Option<RangeQuery<Timestamp>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub customer: Option<CustomerId>,
#[serde(skip_serializing_if = "Option::is_none")]
pub due_date: Option<RangeQuery<Timestamp>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub ending_before: Option<InvoiceId>,
#[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<InvoiceId>,
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<InvoiceStatus>,
#[serde(skip_serializing_if = "Option::is_none")]
pub subscription: Option<SubscriptionId>,
}
impl<'a> ListInvoices<'a> {
pub fn new() -> Self {
ListInvoices {
collection_method: Default::default(),
created: Default::default(),
customer: Default::default(),
due_date: Default::default(),
ending_before: Default::default(),
expand: Default::default(),
limit: Default::default(),
starting_after: Default::default(),
status: Default::default(),
subscription: Default::default(),
}
}
}
impl Paginable for ListInvoices<'_> {
type O = Invoice;
fn set_last(&mut self, item: Self::O) {
self.starting_after = Some(item.id());
}
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateInvoiceAutomaticTax {
pub enabled: bool,
#[serde(skip_serializing_if = "Option::is_none")]
pub liability: Option<CreateInvoiceAutomaticTaxLiability>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateInvoiceCustomFields {
pub name: String,
pub value: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateInvoiceDiscounts {
#[serde(skip_serializing_if = "Option::is_none")]
pub coupon: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub discount: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateInvoiceFromInvoice {
pub action: CreateInvoiceFromInvoiceAction,
pub invoice: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateInvoiceIssuer {
#[serde(skip_serializing_if = "Option::is_none")]
pub account: Option<String>,
#[serde(rename = "type")]
pub type_: CreateInvoiceIssuerType,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateInvoicePaymentSettings {
#[serde(skip_serializing_if = "Option::is_none")]
pub default_mandate: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method_options: Option<CreateInvoicePaymentSettingsPaymentMethodOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method_types: Option<Vec<CreateInvoicePaymentSettingsPaymentMethodTypes>>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateInvoiceRendering {
#[serde(skip_serializing_if = "Option::is_none")]
pub amount_tax_display: Option<CreateInvoiceRenderingAmountTaxDisplay>,
#[serde(skip_serializing_if = "Option::is_none")]
pub pdf: Option<CreateInvoiceRenderingPdf>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateInvoiceRenderingOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub amount_tax_display: Option<CreateInvoiceRenderingOptionsAmountTaxDisplay>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateInvoiceShippingCost {
#[serde(skip_serializing_if = "Option::is_none")]
pub shipping_rate: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub shipping_rate_data: Option<CreateInvoiceShippingCostShippingRateData>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateInvoiceShippingDetails {
pub address: CreateInvoiceShippingDetailsAddress,
pub name: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub phone: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateInvoiceTransferData {
#[serde(skip_serializing_if = "Option::is_none")]
pub amount: Option<i64>,
pub destination: String,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateInvoiceAutomaticTaxLiability {
#[serde(skip_serializing_if = "Option::is_none")]
pub account: Option<String>,
#[serde(rename = "type")]
pub type_: CreateInvoiceAutomaticTaxLiabilityType,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateInvoicePaymentSettingsPaymentMethodOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub acss_debit: Option<CreateInvoicePaymentSettingsPaymentMethodOptionsAcssDebit>,
#[serde(skip_serializing_if = "Option::is_none")]
pub bancontact: Option<CreateInvoicePaymentSettingsPaymentMethodOptionsBancontact>,
#[serde(skip_serializing_if = "Option::is_none")]
pub card: Option<CreateInvoicePaymentSettingsPaymentMethodOptionsCard>,
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_balance: Option<CreateInvoicePaymentSettingsPaymentMethodOptionsCustomerBalance>,
#[serde(skip_serializing_if = "Option::is_none")]
pub konbini: Option<CreateInvoicePaymentSettingsPaymentMethodOptionsKonbini>,
#[serde(skip_serializing_if = "Option::is_none")]
pub us_bank_account: Option<CreateInvoicePaymentSettingsPaymentMethodOptionsUsBankAccount>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateInvoiceRenderingPdf {
#[serde(skip_serializing_if = "Option::is_none")]
pub page_size: Option<CreateInvoiceRenderingPdfPageSize>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateInvoiceShippingCostShippingRateData {
#[serde(skip_serializing_if = "Option::is_none")]
pub delivery_estimate: Option<CreateInvoiceShippingCostShippingRateDataDeliveryEstimate>,
pub display_name: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub fixed_amount: Option<CreateInvoiceShippingCostShippingRateDataFixedAmount>,
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata: Option<Metadata>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tax_behavior: Option<CreateInvoiceShippingCostShippingRateDataTaxBehavior>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tax_code: Option<String>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<CreateInvoiceShippingCostShippingRateDataType>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateInvoiceShippingDetailsAddress {
#[serde(skip_serializing_if = "Option::is_none")]
pub city: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub country: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub line1: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub line2: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub postal_code: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateInvoicePaymentSettingsPaymentMethodOptionsAcssDebit {
#[serde(skip_serializing_if = "Option::is_none")]
pub mandate_options:
Option<CreateInvoicePaymentSettingsPaymentMethodOptionsAcssDebitMandateOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub verification_method:
Option<CreateInvoicePaymentSettingsPaymentMethodOptionsAcssDebitVerificationMethod>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateInvoicePaymentSettingsPaymentMethodOptionsBancontact {
#[serde(skip_serializing_if = "Option::is_none")]
pub preferred_language:
Option<CreateInvoicePaymentSettingsPaymentMethodOptionsBancontactPreferredLanguage>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateInvoicePaymentSettingsPaymentMethodOptionsCard {
#[serde(skip_serializing_if = "Option::is_none")]
pub installments: Option<CreateInvoicePaymentSettingsPaymentMethodOptionsCardInstallments>,
#[serde(skip_serializing_if = "Option::is_none")]
pub request_three_d_secure:
Option<CreateInvoicePaymentSettingsPaymentMethodOptionsCardRequestThreeDSecure>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateInvoicePaymentSettingsPaymentMethodOptionsCustomerBalance {
#[serde(skip_serializing_if = "Option::is_none")]
pub bank_transfer:
Option<CreateInvoicePaymentSettingsPaymentMethodOptionsCustomerBalanceBankTransfer>,
#[serde(skip_serializing_if = "Option::is_none")]
pub funding_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateInvoicePaymentSettingsPaymentMethodOptionsKonbini {}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateInvoicePaymentSettingsPaymentMethodOptionsUsBankAccount {
#[serde(skip_serializing_if = "Option::is_none")]
pub financial_connections:
Option<CreateInvoicePaymentSettingsPaymentMethodOptionsUsBankAccountFinancialConnections>,
#[serde(skip_serializing_if = "Option::is_none")]
pub verification_method:
Option<CreateInvoicePaymentSettingsPaymentMethodOptionsUsBankAccountVerificationMethod>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateInvoiceShippingCostShippingRateDataDeliveryEstimate {
#[serde(skip_serializing_if = "Option::is_none")]
pub maximum: Option<CreateInvoiceShippingCostShippingRateDataDeliveryEstimateMaximum>,
#[serde(skip_serializing_if = "Option::is_none")]
pub minimum: Option<CreateInvoiceShippingCostShippingRateDataDeliveryEstimateMinimum>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateInvoiceShippingCostShippingRateDataFixedAmount {
pub amount: i64,
pub currency: Currency,
#[serde(skip_serializing_if = "Option::is_none")]
pub currency_options:
Option<CurrencyMap<CreateInvoiceShippingCostShippingRateDataFixedAmountCurrencyOptions>>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateInvoicePaymentSettingsPaymentMethodOptionsAcssDebitMandateOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub transaction_type: Option<
CreateInvoicePaymentSettingsPaymentMethodOptionsAcssDebitMandateOptionsTransactionType,
>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateInvoicePaymentSettingsPaymentMethodOptionsCardInstallments {
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub plan: Option<CreateInvoicePaymentSettingsPaymentMethodOptionsCardInstallmentsPlan>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateInvoicePaymentSettingsPaymentMethodOptionsCustomerBalanceBankTransfer {
#[serde(skip_serializing_if = "Option::is_none")]
pub eu_bank_transfer: Option<
CreateInvoicePaymentSettingsPaymentMethodOptionsCustomerBalanceBankTransferEuBankTransfer,
>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateInvoicePaymentSettingsPaymentMethodOptionsUsBankAccountFinancialConnections {
#[serde(skip_serializing_if = "Option::is_none")]
pub permissions: Option<Vec<CreateInvoicePaymentSettingsPaymentMethodOptionsUsBankAccountFinancialConnectionsPermissions>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub prefetch: Option<Vec<CreateInvoicePaymentSettingsPaymentMethodOptionsUsBankAccountFinancialConnectionsPrefetch>>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateInvoiceShippingCostShippingRateDataDeliveryEstimateMaximum {
pub unit: CreateInvoiceShippingCostShippingRateDataDeliveryEstimateMaximumUnit,
pub value: i64,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateInvoiceShippingCostShippingRateDataDeliveryEstimateMinimum {
pub unit: CreateInvoiceShippingCostShippingRateDataDeliveryEstimateMinimumUnit,
pub value: i64,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateInvoiceShippingCostShippingRateDataFixedAmountCurrencyOptions {
pub amount: i64,
#[serde(skip_serializing_if = "Option::is_none")]
pub tax_behavior:
Option<CreateInvoiceShippingCostShippingRateDataFixedAmountCurrencyOptionsTaxBehavior>,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateInvoicePaymentSettingsPaymentMethodOptionsCardInstallmentsPlan {
pub count: u64,
pub interval: CreateInvoicePaymentSettingsPaymentMethodOptionsCardInstallmentsPlanInterval,
#[serde(rename = "type")]
pub type_: CreateInvoicePaymentSettingsPaymentMethodOptionsCardInstallmentsPlanType,
}
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct CreateInvoicePaymentSettingsPaymentMethodOptionsCustomerBalanceBankTransferEuBankTransfer
{
pub country: String,
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum AutomaticTaxStatus {
Complete,
Failed,
RequiresLocationInputs,
}
impl AutomaticTaxStatus {
pub fn as_str(self) -> &'static str {
match self {
AutomaticTaxStatus::Complete => "complete",
AutomaticTaxStatus::Failed => "failed",
AutomaticTaxStatus::RequiresLocationInputs => "requires_location_inputs",
}
}
}
impl AsRef<str> for AutomaticTaxStatus {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for AutomaticTaxStatus {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for AutomaticTaxStatus {
fn default() -> Self {
Self::Complete
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CollectionMethod {
ChargeAutomatically,
SendInvoice,
}
impl CollectionMethod {
pub fn as_str(self) -> &'static str {
match self {
CollectionMethod::ChargeAutomatically => "charge_automatically",
CollectionMethod::SendInvoice => "send_invoice",
}
}
}
impl AsRef<str> for CollectionMethod {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CollectionMethod {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CollectionMethod {
fn default() -> Self {
Self::ChargeAutomatically
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateInvoiceAutomaticTaxLiabilityType {
Account,
#[serde(rename = "self")]
Self_,
}
impl CreateInvoiceAutomaticTaxLiabilityType {
pub fn as_str(self) -> &'static str {
match self {
CreateInvoiceAutomaticTaxLiabilityType::Account => "account",
CreateInvoiceAutomaticTaxLiabilityType::Self_ => "self",
}
}
}
impl AsRef<str> for CreateInvoiceAutomaticTaxLiabilityType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateInvoiceAutomaticTaxLiabilityType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateInvoiceAutomaticTaxLiabilityType {
fn default() -> Self {
Self::Account
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateInvoiceFromInvoiceAction {
Revision,
}
impl CreateInvoiceFromInvoiceAction {
pub fn as_str(self) -> &'static str {
match self {
CreateInvoiceFromInvoiceAction::Revision => "revision",
}
}
}
impl AsRef<str> for CreateInvoiceFromInvoiceAction {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateInvoiceFromInvoiceAction {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateInvoiceFromInvoiceAction {
fn default() -> Self {
Self::Revision
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateInvoiceIssuerType {
Account,
#[serde(rename = "self")]
Self_,
}
impl CreateInvoiceIssuerType {
pub fn as_str(self) -> &'static str {
match self {
CreateInvoiceIssuerType::Account => "account",
CreateInvoiceIssuerType::Self_ => "self",
}
}
}
impl AsRef<str> for CreateInvoiceIssuerType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateInvoiceIssuerType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateInvoiceIssuerType {
fn default() -> Self {
Self::Account
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateInvoicePaymentSettingsPaymentMethodOptionsAcssDebitMandateOptionsTransactionType {
Business,
Personal,
}
impl CreateInvoicePaymentSettingsPaymentMethodOptionsAcssDebitMandateOptionsTransactionType {
pub fn as_str(self) -> &'static str {
match self {
CreateInvoicePaymentSettingsPaymentMethodOptionsAcssDebitMandateOptionsTransactionType::Business => "business",
CreateInvoicePaymentSettingsPaymentMethodOptionsAcssDebitMandateOptionsTransactionType::Personal => "personal",
}
}
}
impl AsRef<str>
for CreateInvoicePaymentSettingsPaymentMethodOptionsAcssDebitMandateOptionsTransactionType
{
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display
for CreateInvoicePaymentSettingsPaymentMethodOptionsAcssDebitMandateOptionsTransactionType
{
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CreateInvoicePaymentSettingsPaymentMethodOptionsAcssDebitMandateOptionsTransactionType
{
fn default() -> Self {
Self::Business
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateInvoicePaymentSettingsPaymentMethodOptionsAcssDebitVerificationMethod {
Automatic,
Instant,
Microdeposits,
}
impl CreateInvoicePaymentSettingsPaymentMethodOptionsAcssDebitVerificationMethod {
pub fn as_str(self) -> &'static str {
match self {
CreateInvoicePaymentSettingsPaymentMethodOptionsAcssDebitVerificationMethod::Automatic => "automatic",
CreateInvoicePaymentSettingsPaymentMethodOptionsAcssDebitVerificationMethod::Instant => "instant",
CreateInvoicePaymentSettingsPaymentMethodOptionsAcssDebitVerificationMethod::Microdeposits => "microdeposits",
}
}
}
impl AsRef<str> for CreateInvoicePaymentSettingsPaymentMethodOptionsAcssDebitVerificationMethod {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display
for CreateInvoicePaymentSettingsPaymentMethodOptionsAcssDebitVerificationMethod
{
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CreateInvoicePaymentSettingsPaymentMethodOptionsAcssDebitVerificationMethod
{
fn default() -> Self {
Self::Automatic
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateInvoicePaymentSettingsPaymentMethodOptionsBancontactPreferredLanguage {
De,
En,
Fr,
Nl,
}
impl CreateInvoicePaymentSettingsPaymentMethodOptionsBancontactPreferredLanguage {
pub fn as_str(self) -> &'static str {
match self {
CreateInvoicePaymentSettingsPaymentMethodOptionsBancontactPreferredLanguage::De => "de",
CreateInvoicePaymentSettingsPaymentMethodOptionsBancontactPreferredLanguage::En => "en",
CreateInvoicePaymentSettingsPaymentMethodOptionsBancontactPreferredLanguage::Fr => "fr",
CreateInvoicePaymentSettingsPaymentMethodOptionsBancontactPreferredLanguage::Nl => "nl",
}
}
}
impl AsRef<str> for CreateInvoicePaymentSettingsPaymentMethodOptionsBancontactPreferredLanguage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display
for CreateInvoicePaymentSettingsPaymentMethodOptionsBancontactPreferredLanguage
{
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CreateInvoicePaymentSettingsPaymentMethodOptionsBancontactPreferredLanguage
{
fn default() -> Self {
Self::De
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateInvoicePaymentSettingsPaymentMethodOptionsCardInstallmentsPlanInterval {
Month,
}
impl CreateInvoicePaymentSettingsPaymentMethodOptionsCardInstallmentsPlanInterval {
pub fn as_str(self) -> &'static str {
match self {
CreateInvoicePaymentSettingsPaymentMethodOptionsCardInstallmentsPlanInterval::Month => {
"month"
}
}
}
}
impl AsRef<str> for CreateInvoicePaymentSettingsPaymentMethodOptionsCardInstallmentsPlanInterval {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display
for CreateInvoicePaymentSettingsPaymentMethodOptionsCardInstallmentsPlanInterval
{
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CreateInvoicePaymentSettingsPaymentMethodOptionsCardInstallmentsPlanInterval
{
fn default() -> Self {
Self::Month
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateInvoicePaymentSettingsPaymentMethodOptionsCardInstallmentsPlanType {
FixedCount,
}
impl CreateInvoicePaymentSettingsPaymentMethodOptionsCardInstallmentsPlanType {
pub fn as_str(self) -> &'static str {
match self {
CreateInvoicePaymentSettingsPaymentMethodOptionsCardInstallmentsPlanType::FixedCount => "fixed_count",
}
}
}
impl AsRef<str> for CreateInvoicePaymentSettingsPaymentMethodOptionsCardInstallmentsPlanType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display
for CreateInvoicePaymentSettingsPaymentMethodOptionsCardInstallmentsPlanType
{
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CreateInvoicePaymentSettingsPaymentMethodOptionsCardInstallmentsPlanType
{
fn default() -> Self {
Self::FixedCount
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateInvoicePaymentSettingsPaymentMethodOptionsCardRequestThreeDSecure {
Any,
Automatic,
Challenge,
}
impl CreateInvoicePaymentSettingsPaymentMethodOptionsCardRequestThreeDSecure {
pub fn as_str(self) -> &'static str {
match self {
CreateInvoicePaymentSettingsPaymentMethodOptionsCardRequestThreeDSecure::Any => "any",
CreateInvoicePaymentSettingsPaymentMethodOptionsCardRequestThreeDSecure::Automatic => {
"automatic"
}
CreateInvoicePaymentSettingsPaymentMethodOptionsCardRequestThreeDSecure::Challenge => {
"challenge"
}
}
}
}
impl AsRef<str> for CreateInvoicePaymentSettingsPaymentMethodOptionsCardRequestThreeDSecure {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateInvoicePaymentSettingsPaymentMethodOptionsCardRequestThreeDSecure {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CreateInvoicePaymentSettingsPaymentMethodOptionsCardRequestThreeDSecure
{
fn default() -> Self {
Self::Any
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateInvoicePaymentSettingsPaymentMethodOptionsUsBankAccountFinancialConnectionsPermissions
{
Balances,
Ownership,
PaymentMethod,
Transactions,
}
impl CreateInvoicePaymentSettingsPaymentMethodOptionsUsBankAccountFinancialConnectionsPermissions {
pub fn as_str(self) -> &'static str {
match self {
CreateInvoicePaymentSettingsPaymentMethodOptionsUsBankAccountFinancialConnectionsPermissions::Balances => "balances",
CreateInvoicePaymentSettingsPaymentMethodOptionsUsBankAccountFinancialConnectionsPermissions::Ownership => "ownership",
CreateInvoicePaymentSettingsPaymentMethodOptionsUsBankAccountFinancialConnectionsPermissions::PaymentMethod => "payment_method",
CreateInvoicePaymentSettingsPaymentMethodOptionsUsBankAccountFinancialConnectionsPermissions::Transactions => "transactions",
}
}
}
impl AsRef<str>
for CreateInvoicePaymentSettingsPaymentMethodOptionsUsBankAccountFinancialConnectionsPermissions
{
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display
for CreateInvoicePaymentSettingsPaymentMethodOptionsUsBankAccountFinancialConnectionsPermissions
{
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CreateInvoicePaymentSettingsPaymentMethodOptionsUsBankAccountFinancialConnectionsPermissions
{
fn default() -> Self {
Self::Balances
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateInvoicePaymentSettingsPaymentMethodOptionsUsBankAccountFinancialConnectionsPrefetch {
Balances,
Transactions,
}
impl CreateInvoicePaymentSettingsPaymentMethodOptionsUsBankAccountFinancialConnectionsPrefetch {
pub fn as_str(self) -> &'static str {
match self {
CreateInvoicePaymentSettingsPaymentMethodOptionsUsBankAccountFinancialConnectionsPrefetch::Balances => "balances",
CreateInvoicePaymentSettingsPaymentMethodOptionsUsBankAccountFinancialConnectionsPrefetch::Transactions => "transactions",
}
}
}
impl AsRef<str>
for CreateInvoicePaymentSettingsPaymentMethodOptionsUsBankAccountFinancialConnectionsPrefetch
{
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display
for CreateInvoicePaymentSettingsPaymentMethodOptionsUsBankAccountFinancialConnectionsPrefetch
{
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CreateInvoicePaymentSettingsPaymentMethodOptionsUsBankAccountFinancialConnectionsPrefetch
{
fn default() -> Self {
Self::Balances
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateInvoicePaymentSettingsPaymentMethodOptionsUsBankAccountVerificationMethod {
Automatic,
Instant,
Microdeposits,
}
impl CreateInvoicePaymentSettingsPaymentMethodOptionsUsBankAccountVerificationMethod {
pub fn as_str(self) -> &'static str {
match self {
CreateInvoicePaymentSettingsPaymentMethodOptionsUsBankAccountVerificationMethod::Automatic => "automatic",
CreateInvoicePaymentSettingsPaymentMethodOptionsUsBankAccountVerificationMethod::Instant => "instant",
CreateInvoicePaymentSettingsPaymentMethodOptionsUsBankAccountVerificationMethod::Microdeposits => "microdeposits",
}
}
}
impl AsRef<str>
for CreateInvoicePaymentSettingsPaymentMethodOptionsUsBankAccountVerificationMethod
{
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display
for CreateInvoicePaymentSettingsPaymentMethodOptionsUsBankAccountVerificationMethod
{
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CreateInvoicePaymentSettingsPaymentMethodOptionsUsBankAccountVerificationMethod
{
fn default() -> Self {
Self::Automatic
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateInvoicePaymentSettingsPaymentMethodTypes {
AchCreditTransfer,
AchDebit,
AcssDebit,
AuBecsDebit,
BacsDebit,
Bancontact,
Boleto,
Card,
Cashapp,
CustomerBalance,
Eps,
Fpx,
Giropay,
Grabpay,
Ideal,
Konbini,
Link,
P24,
Paynow,
Paypal,
Promptpay,
SepaCreditTransfer,
SepaDebit,
Sofort,
UsBankAccount,
WechatPay,
}
impl CreateInvoicePaymentSettingsPaymentMethodTypes {
pub fn as_str(self) -> &'static str {
match self {
CreateInvoicePaymentSettingsPaymentMethodTypes::AchCreditTransfer => {
"ach_credit_transfer"
}
CreateInvoicePaymentSettingsPaymentMethodTypes::AchDebit => "ach_debit",
CreateInvoicePaymentSettingsPaymentMethodTypes::AcssDebit => "acss_debit",
CreateInvoicePaymentSettingsPaymentMethodTypes::AuBecsDebit => "au_becs_debit",
CreateInvoicePaymentSettingsPaymentMethodTypes::BacsDebit => "bacs_debit",
CreateInvoicePaymentSettingsPaymentMethodTypes::Bancontact => "bancontact",
CreateInvoicePaymentSettingsPaymentMethodTypes::Boleto => "boleto",
CreateInvoicePaymentSettingsPaymentMethodTypes::Card => "card",
CreateInvoicePaymentSettingsPaymentMethodTypes::Cashapp => "cashapp",
CreateInvoicePaymentSettingsPaymentMethodTypes::CustomerBalance => "customer_balance",
CreateInvoicePaymentSettingsPaymentMethodTypes::Eps => "eps",
CreateInvoicePaymentSettingsPaymentMethodTypes::Fpx => "fpx",
CreateInvoicePaymentSettingsPaymentMethodTypes::Giropay => "giropay",
CreateInvoicePaymentSettingsPaymentMethodTypes::Grabpay => "grabpay",
CreateInvoicePaymentSettingsPaymentMethodTypes::Ideal => "ideal",
CreateInvoicePaymentSettingsPaymentMethodTypes::Konbini => "konbini",
CreateInvoicePaymentSettingsPaymentMethodTypes::Link => "link",
CreateInvoicePaymentSettingsPaymentMethodTypes::P24 => "p24",
CreateInvoicePaymentSettingsPaymentMethodTypes::Paynow => "paynow",
CreateInvoicePaymentSettingsPaymentMethodTypes::Paypal => "paypal",
CreateInvoicePaymentSettingsPaymentMethodTypes::Promptpay => "promptpay",
CreateInvoicePaymentSettingsPaymentMethodTypes::SepaCreditTransfer => {
"sepa_credit_transfer"
}
CreateInvoicePaymentSettingsPaymentMethodTypes::SepaDebit => "sepa_debit",
CreateInvoicePaymentSettingsPaymentMethodTypes::Sofort => "sofort",
CreateInvoicePaymentSettingsPaymentMethodTypes::UsBankAccount => "us_bank_account",
CreateInvoicePaymentSettingsPaymentMethodTypes::WechatPay => "wechat_pay",
}
}
}
impl AsRef<str> for CreateInvoicePaymentSettingsPaymentMethodTypes {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateInvoicePaymentSettingsPaymentMethodTypes {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateInvoicePaymentSettingsPaymentMethodTypes {
fn default() -> Self {
Self::AchCreditTransfer
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateInvoiceRenderingAmountTaxDisplay {
ExcludeTax,
IncludeInclusiveTax,
}
impl CreateInvoiceRenderingAmountTaxDisplay {
pub fn as_str(self) -> &'static str {
match self {
CreateInvoiceRenderingAmountTaxDisplay::ExcludeTax => "exclude_tax",
CreateInvoiceRenderingAmountTaxDisplay::IncludeInclusiveTax => "include_inclusive_tax",
}
}
}
impl AsRef<str> for CreateInvoiceRenderingAmountTaxDisplay {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateInvoiceRenderingAmountTaxDisplay {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateInvoiceRenderingAmountTaxDisplay {
fn default() -> Self {
Self::ExcludeTax
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateInvoiceRenderingOptionsAmountTaxDisplay {
ExcludeTax,
IncludeInclusiveTax,
}
impl CreateInvoiceRenderingOptionsAmountTaxDisplay {
pub fn as_str(self) -> &'static str {
match self {
CreateInvoiceRenderingOptionsAmountTaxDisplay::ExcludeTax => "exclude_tax",
CreateInvoiceRenderingOptionsAmountTaxDisplay::IncludeInclusiveTax => {
"include_inclusive_tax"
}
}
}
}
impl AsRef<str> for CreateInvoiceRenderingOptionsAmountTaxDisplay {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateInvoiceRenderingOptionsAmountTaxDisplay {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateInvoiceRenderingOptionsAmountTaxDisplay {
fn default() -> Self {
Self::ExcludeTax
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateInvoiceRenderingPdfPageSize {
A4,
Auto,
Letter,
}
impl CreateInvoiceRenderingPdfPageSize {
pub fn as_str(self) -> &'static str {
match self {
CreateInvoiceRenderingPdfPageSize::A4 => "a4",
CreateInvoiceRenderingPdfPageSize::Auto => "auto",
CreateInvoiceRenderingPdfPageSize::Letter => "letter",
}
}
}
impl AsRef<str> for CreateInvoiceRenderingPdfPageSize {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateInvoiceRenderingPdfPageSize {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateInvoiceRenderingPdfPageSize {
fn default() -> Self {
Self::A4
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateInvoiceShippingCostShippingRateDataDeliveryEstimateMaximumUnit {
BusinessDay,
Day,
Hour,
Month,
Week,
}
impl CreateInvoiceShippingCostShippingRateDataDeliveryEstimateMaximumUnit {
pub fn as_str(self) -> &'static str {
match self {
CreateInvoiceShippingCostShippingRateDataDeliveryEstimateMaximumUnit::BusinessDay => {
"business_day"
}
CreateInvoiceShippingCostShippingRateDataDeliveryEstimateMaximumUnit::Day => "day",
CreateInvoiceShippingCostShippingRateDataDeliveryEstimateMaximumUnit::Hour => "hour",
CreateInvoiceShippingCostShippingRateDataDeliveryEstimateMaximumUnit::Month => "month",
CreateInvoiceShippingCostShippingRateDataDeliveryEstimateMaximumUnit::Week => "week",
}
}
}
impl AsRef<str> for CreateInvoiceShippingCostShippingRateDataDeliveryEstimateMaximumUnit {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateInvoiceShippingCostShippingRateDataDeliveryEstimateMaximumUnit {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CreateInvoiceShippingCostShippingRateDataDeliveryEstimateMaximumUnit
{
fn default() -> Self {
Self::BusinessDay
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateInvoiceShippingCostShippingRateDataDeliveryEstimateMinimumUnit {
BusinessDay,
Day,
Hour,
Month,
Week,
}
impl CreateInvoiceShippingCostShippingRateDataDeliveryEstimateMinimumUnit {
pub fn as_str(self) -> &'static str {
match self {
CreateInvoiceShippingCostShippingRateDataDeliveryEstimateMinimumUnit::BusinessDay => {
"business_day"
}
CreateInvoiceShippingCostShippingRateDataDeliveryEstimateMinimumUnit::Day => "day",
CreateInvoiceShippingCostShippingRateDataDeliveryEstimateMinimumUnit::Hour => "hour",
CreateInvoiceShippingCostShippingRateDataDeliveryEstimateMinimumUnit::Month => "month",
CreateInvoiceShippingCostShippingRateDataDeliveryEstimateMinimumUnit::Week => "week",
}
}
}
impl AsRef<str> for CreateInvoiceShippingCostShippingRateDataDeliveryEstimateMinimumUnit {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateInvoiceShippingCostShippingRateDataDeliveryEstimateMinimumUnit {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CreateInvoiceShippingCostShippingRateDataDeliveryEstimateMinimumUnit
{
fn default() -> Self {
Self::BusinessDay
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateInvoiceShippingCostShippingRateDataFixedAmountCurrencyOptionsTaxBehavior {
Exclusive,
Inclusive,
Unspecified,
}
impl CreateInvoiceShippingCostShippingRateDataFixedAmountCurrencyOptionsTaxBehavior {
pub fn as_str(self) -> &'static str {
match self {
CreateInvoiceShippingCostShippingRateDataFixedAmountCurrencyOptionsTaxBehavior::Exclusive => "exclusive",
CreateInvoiceShippingCostShippingRateDataFixedAmountCurrencyOptionsTaxBehavior::Inclusive => "inclusive",
CreateInvoiceShippingCostShippingRateDataFixedAmountCurrencyOptionsTaxBehavior::Unspecified => "unspecified",
}
}
}
impl AsRef<str> for CreateInvoiceShippingCostShippingRateDataFixedAmountCurrencyOptionsTaxBehavior {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display
for CreateInvoiceShippingCostShippingRateDataFixedAmountCurrencyOptionsTaxBehavior
{
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default
for CreateInvoiceShippingCostShippingRateDataFixedAmountCurrencyOptionsTaxBehavior
{
fn default() -> Self {
Self::Exclusive
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateInvoiceShippingCostShippingRateDataTaxBehavior {
Exclusive,
Inclusive,
Unspecified,
}
impl CreateInvoiceShippingCostShippingRateDataTaxBehavior {
pub fn as_str(self) -> &'static str {
match self {
CreateInvoiceShippingCostShippingRateDataTaxBehavior::Exclusive => "exclusive",
CreateInvoiceShippingCostShippingRateDataTaxBehavior::Inclusive => "inclusive",
CreateInvoiceShippingCostShippingRateDataTaxBehavior::Unspecified => "unspecified",
}
}
}
impl AsRef<str> for CreateInvoiceShippingCostShippingRateDataTaxBehavior {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateInvoiceShippingCostShippingRateDataTaxBehavior {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateInvoiceShippingCostShippingRateDataTaxBehavior {
fn default() -> Self {
Self::Exclusive
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateInvoiceShippingCostShippingRateDataType {
FixedAmount,
}
impl CreateInvoiceShippingCostShippingRateDataType {
pub fn as_str(self) -> &'static str {
match self {
CreateInvoiceShippingCostShippingRateDataType::FixedAmount => "fixed_amount",
}
}
}
impl AsRef<str> for CreateInvoiceShippingCostShippingRateDataType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateInvoiceShippingCostShippingRateDataType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for CreateInvoiceShippingCostShippingRateDataType {
fn default() -> Self {
Self::FixedAmount
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum InvoiceBillingReason {
AutomaticPendingInvoiceItemInvoice,
Manual,
QuoteAccept,
Subscription,
SubscriptionCreate,
SubscriptionCycle,
SubscriptionThreshold,
SubscriptionUpdate,
Upcoming,
}
impl InvoiceBillingReason {
pub fn as_str(self) -> &'static str {
match self {
InvoiceBillingReason::AutomaticPendingInvoiceItemInvoice => {
"automatic_pending_invoice_item_invoice"
}
InvoiceBillingReason::Manual => "manual",
InvoiceBillingReason::QuoteAccept => "quote_accept",
InvoiceBillingReason::Subscription => "subscription",
InvoiceBillingReason::SubscriptionCreate => "subscription_create",
InvoiceBillingReason::SubscriptionCycle => "subscription_cycle",
InvoiceBillingReason::SubscriptionThreshold => "subscription_threshold",
InvoiceBillingReason::SubscriptionUpdate => "subscription_update",
InvoiceBillingReason::Upcoming => "upcoming",
}
}
}
impl AsRef<str> for InvoiceBillingReason {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for InvoiceBillingReason {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for InvoiceBillingReason {
fn default() -> Self {
Self::AutomaticPendingInvoiceItemInvoice
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum InvoiceCustomerTaxExempt {
Exempt,
None,
Reverse,
}
impl InvoiceCustomerTaxExempt {
pub fn as_str(self) -> &'static str {
match self {
InvoiceCustomerTaxExempt::Exempt => "exempt",
InvoiceCustomerTaxExempt::None => "none",
InvoiceCustomerTaxExempt::Reverse => "reverse",
}
}
}
impl AsRef<str> for InvoiceCustomerTaxExempt {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for InvoiceCustomerTaxExempt {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for InvoiceCustomerTaxExempt {
fn default() -> Self {
Self::Exempt
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum InvoicePaymentMethodOptionsCardRequestThreeDSecure {
Any,
Automatic,
Challenge,
}
impl InvoicePaymentMethodOptionsCardRequestThreeDSecure {
pub fn as_str(self) -> &'static str {
match self {
InvoicePaymentMethodOptionsCardRequestThreeDSecure::Any => "any",
InvoicePaymentMethodOptionsCardRequestThreeDSecure::Automatic => "automatic",
InvoicePaymentMethodOptionsCardRequestThreeDSecure::Challenge => "challenge",
}
}
}
impl AsRef<str> for InvoicePaymentMethodOptionsCardRequestThreeDSecure {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for InvoicePaymentMethodOptionsCardRequestThreeDSecure {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for InvoicePaymentMethodOptionsCardRequestThreeDSecure {
fn default() -> Self {
Self::Any
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum InvoicePendingInvoiceItemsBehavior {
Exclude,
Include,
IncludeAndRequire,
}
impl InvoicePendingInvoiceItemsBehavior {
pub fn as_str(self) -> &'static str {
match self {
InvoicePendingInvoiceItemsBehavior::Exclude => "exclude",
InvoicePendingInvoiceItemsBehavior::Include => "include",
InvoicePendingInvoiceItemsBehavior::IncludeAndRequire => "include_and_require",
}
}
}
impl AsRef<str> for InvoicePendingInvoiceItemsBehavior {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for InvoicePendingInvoiceItemsBehavior {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for InvoicePendingInvoiceItemsBehavior {
fn default() -> Self {
Self::Exclude
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum InvoiceRenderingPdfPageSize {
A4,
Auto,
Letter,
}
impl InvoiceRenderingPdfPageSize {
pub fn as_str(self) -> &'static str {
match self {
InvoiceRenderingPdfPageSize::A4 => "a4",
InvoiceRenderingPdfPageSize::Auto => "auto",
InvoiceRenderingPdfPageSize::Letter => "letter",
}
}
}
impl AsRef<str> for InvoiceRenderingPdfPageSize {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for InvoiceRenderingPdfPageSize {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for InvoiceRenderingPdfPageSize {
fn default() -> Self {
Self::A4
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum InvoiceStatus {
Draft,
Open,
Paid,
Uncollectible,
Void,
}
impl InvoiceStatus {
pub fn as_str(self) -> &'static str {
match self {
InvoiceStatus::Draft => "draft",
InvoiceStatus::Open => "open",
InvoiceStatus::Paid => "paid",
InvoiceStatus::Uncollectible => "uncollectible",
InvoiceStatus::Void => "void",
}
}
}
impl AsRef<str> for InvoiceStatus {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for InvoiceStatus {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for InvoiceStatus {
fn default() -> Self {
Self::Draft
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum InvoicesPaymentSettingsPaymentMethodTypes {
AchCreditTransfer,
AchDebit,
AcssDebit,
AuBecsDebit,
BacsDebit,
Bancontact,
Boleto,
Card,
Cashapp,
CustomerBalance,
Eps,
Fpx,
Giropay,
Grabpay,
Ideal,
Konbini,
Link,
P24,
Paynow,
Paypal,
Promptpay,
SepaCreditTransfer,
SepaDebit,
Sofort,
UsBankAccount,
WechatPay,
}
impl InvoicesPaymentSettingsPaymentMethodTypes {
pub fn as_str(self) -> &'static str {
match self {
InvoicesPaymentSettingsPaymentMethodTypes::AchCreditTransfer => "ach_credit_transfer",
InvoicesPaymentSettingsPaymentMethodTypes::AchDebit => "ach_debit",
InvoicesPaymentSettingsPaymentMethodTypes::AcssDebit => "acss_debit",
InvoicesPaymentSettingsPaymentMethodTypes::AuBecsDebit => "au_becs_debit",
InvoicesPaymentSettingsPaymentMethodTypes::BacsDebit => "bacs_debit",
InvoicesPaymentSettingsPaymentMethodTypes::Bancontact => "bancontact",
InvoicesPaymentSettingsPaymentMethodTypes::Boleto => "boleto",
InvoicesPaymentSettingsPaymentMethodTypes::Card => "card",
InvoicesPaymentSettingsPaymentMethodTypes::Cashapp => "cashapp",
InvoicesPaymentSettingsPaymentMethodTypes::CustomerBalance => "customer_balance",
InvoicesPaymentSettingsPaymentMethodTypes::Eps => "eps",
InvoicesPaymentSettingsPaymentMethodTypes::Fpx => "fpx",
InvoicesPaymentSettingsPaymentMethodTypes::Giropay => "giropay",
InvoicesPaymentSettingsPaymentMethodTypes::Grabpay => "grabpay",
InvoicesPaymentSettingsPaymentMethodTypes::Ideal => "ideal",
InvoicesPaymentSettingsPaymentMethodTypes::Konbini => "konbini",
InvoicesPaymentSettingsPaymentMethodTypes::Link => "link",
InvoicesPaymentSettingsPaymentMethodTypes::P24 => "p24",
InvoicesPaymentSettingsPaymentMethodTypes::Paynow => "paynow",
InvoicesPaymentSettingsPaymentMethodTypes::Paypal => "paypal",
InvoicesPaymentSettingsPaymentMethodTypes::Promptpay => "promptpay",
InvoicesPaymentSettingsPaymentMethodTypes::SepaCreditTransfer => "sepa_credit_transfer",
InvoicesPaymentSettingsPaymentMethodTypes::SepaDebit => "sepa_debit",
InvoicesPaymentSettingsPaymentMethodTypes::Sofort => "sofort",
InvoicesPaymentSettingsPaymentMethodTypes::UsBankAccount => "us_bank_account",
InvoicesPaymentSettingsPaymentMethodTypes::WechatPay => "wechat_pay",
}
}
}
impl AsRef<str> for InvoicesPaymentSettingsPaymentMethodTypes {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for InvoicesPaymentSettingsPaymentMethodTypes {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for InvoicesPaymentSettingsPaymentMethodTypes {
fn default() -> Self {
Self::AchCreditTransfer
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum TaxAmountTaxabilityReason {
CustomerExempt,
NotCollecting,
NotSubjectToTax,
NotSupported,
PortionProductExempt,
PortionReducedRated,
PortionStandardRated,
ProductExempt,
ProductExemptHoliday,
ProportionallyRated,
ReducedRated,
ReverseCharge,
StandardRated,
TaxableBasisReduced,
ZeroRated,
}
impl TaxAmountTaxabilityReason {
pub fn as_str(self) -> &'static str {
match self {
TaxAmountTaxabilityReason::CustomerExempt => "customer_exempt",
TaxAmountTaxabilityReason::NotCollecting => "not_collecting",
TaxAmountTaxabilityReason::NotSubjectToTax => "not_subject_to_tax",
TaxAmountTaxabilityReason::NotSupported => "not_supported",
TaxAmountTaxabilityReason::PortionProductExempt => "portion_product_exempt",
TaxAmountTaxabilityReason::PortionReducedRated => "portion_reduced_rated",
TaxAmountTaxabilityReason::PortionStandardRated => "portion_standard_rated",
TaxAmountTaxabilityReason::ProductExempt => "product_exempt",
TaxAmountTaxabilityReason::ProductExemptHoliday => "product_exempt_holiday",
TaxAmountTaxabilityReason::ProportionallyRated => "proportionally_rated",
TaxAmountTaxabilityReason::ReducedRated => "reduced_rated",
TaxAmountTaxabilityReason::ReverseCharge => "reverse_charge",
TaxAmountTaxabilityReason::StandardRated => "standard_rated",
TaxAmountTaxabilityReason::TaxableBasisReduced => "taxable_basis_reduced",
TaxAmountTaxabilityReason::ZeroRated => "zero_rated",
}
}
}
impl AsRef<str> for TaxAmountTaxabilityReason {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for TaxAmountTaxabilityReason {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for TaxAmountTaxabilityReason {
fn default() -> Self {
Self::CustomerExempt
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum TaxIdType {
AdNrt,
AeTrn,
ArCuit,
AuAbn,
AuArn,
BgUic,
BoTin,
BrCnpj,
BrCpf,
CaBn,
CaGstHst,
CaPstBc,
CaPstMb,
CaPstSk,
CaQst,
ChVat,
ClTin,
CnTin,
CoNit,
CrTin,
DoRcn,
EcRuc,
EgTin,
EsCif,
EuOssVat,
EuVat,
GbVat,
GeVat,
HkBr,
HuTin,
IdNpwp,
IlVat,
InGst,
IsVat,
JpCn,
JpRn,
JpTrn,
KePin,
KrBrn,
LiUid,
MxRfc,
MyFrp,
MyItn,
MySst,
NoVat,
NzGst,
PeRuc,
PhTin,
RoTin,
RsPib,
RuInn,
RuKpp,
SaVat,
SgGst,
SgUen,
SiTin,
SvNit,
ThVat,
TrTin,
TwVat,
UaVat,
Unknown,
UsEin,
UyRuc,
VeRif,
VnTin,
ZaVat,
}
impl TaxIdType {
pub fn as_str(self) -> &'static str {
match self {
TaxIdType::AdNrt => "ad_nrt",
TaxIdType::AeTrn => "ae_trn",
TaxIdType::ArCuit => "ar_cuit",
TaxIdType::AuAbn => "au_abn",
TaxIdType::AuArn => "au_arn",
TaxIdType::BgUic => "bg_uic",
TaxIdType::BoTin => "bo_tin",
TaxIdType::BrCnpj => "br_cnpj",
TaxIdType::BrCpf => "br_cpf",
TaxIdType::CaBn => "ca_bn",
TaxIdType::CaGstHst => "ca_gst_hst",
TaxIdType::CaPstBc => "ca_pst_bc",
TaxIdType::CaPstMb => "ca_pst_mb",
TaxIdType::CaPstSk => "ca_pst_sk",
TaxIdType::CaQst => "ca_qst",
TaxIdType::ChVat => "ch_vat",
TaxIdType::ClTin => "cl_tin",
TaxIdType::CnTin => "cn_tin",
TaxIdType::CoNit => "co_nit",
TaxIdType::CrTin => "cr_tin",
TaxIdType::DoRcn => "do_rcn",
TaxIdType::EcRuc => "ec_ruc",
TaxIdType::EgTin => "eg_tin",
TaxIdType::EsCif => "es_cif",
TaxIdType::EuOssVat => "eu_oss_vat",
TaxIdType::EuVat => "eu_vat",
TaxIdType::GbVat => "gb_vat",
TaxIdType::GeVat => "ge_vat",
TaxIdType::HkBr => "hk_br",
TaxIdType::HuTin => "hu_tin",
TaxIdType::IdNpwp => "id_npwp",
TaxIdType::IlVat => "il_vat",
TaxIdType::InGst => "in_gst",
TaxIdType::IsVat => "is_vat",
TaxIdType::JpCn => "jp_cn",
TaxIdType::JpRn => "jp_rn",
TaxIdType::JpTrn => "jp_trn",
TaxIdType::KePin => "ke_pin",
TaxIdType::KrBrn => "kr_brn",
TaxIdType::LiUid => "li_uid",
TaxIdType::MxRfc => "mx_rfc",
TaxIdType::MyFrp => "my_frp",
TaxIdType::MyItn => "my_itn",
TaxIdType::MySst => "my_sst",
TaxIdType::NoVat => "no_vat",
TaxIdType::NzGst => "nz_gst",
TaxIdType::PeRuc => "pe_ruc",
TaxIdType::PhTin => "ph_tin",
TaxIdType::RoTin => "ro_tin",
TaxIdType::RsPib => "rs_pib",
TaxIdType::RuInn => "ru_inn",
TaxIdType::RuKpp => "ru_kpp",
TaxIdType::SaVat => "sa_vat",
TaxIdType::SgGst => "sg_gst",
TaxIdType::SgUen => "sg_uen",
TaxIdType::SiTin => "si_tin",
TaxIdType::SvNit => "sv_nit",
TaxIdType::ThVat => "th_vat",
TaxIdType::TrTin => "tr_tin",
TaxIdType::TwVat => "tw_vat",
TaxIdType::UaVat => "ua_vat",
TaxIdType::Unknown => "unknown",
TaxIdType::UsEin => "us_ein",
TaxIdType::UyRuc => "uy_ruc",
TaxIdType::VeRif => "ve_rif",
TaxIdType::VnTin => "vn_tin",
TaxIdType::ZaVat => "za_vat",
}
}
}
impl AsRef<str> for TaxIdType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for TaxIdType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
impl std::default::Default for TaxIdType {
fn default() -> Self {
Self::AdNrt
}
}