use serde_derive::{Deserialize, Serialize};
use crate::config::{Client, Response};
use crate::ids::{CustomerId, InvoiceId, SubscriptionId};
use crate::params::{Deleted, Expand, Expandable, List, Metadata, Object, RangeQuery, Timestamp};
use crate::resources::{
Account, Address, ApiErrors, Charge, Currency, CustomField, Customer, Discount,
InvoiceLineItem, PaymentIntent, PaymentMethod, PaymentSource, Shipping, Subscription, TaxId,
TaxRate,
};
#[derive(Clone, Debug, 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 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 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 ending_balance: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub footer: Option<String>,
#[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 last_finalization_error: Option<ApiErrors>,
#[serde(default)]
pub lines: List<InvoiceLineItem>,
#[serde(skip_serializing_if = "Option::is_none")]
pub livemode: Option<bool>,
#[serde(default)]
pub metadata: 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 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 receipt_number: Option<String>,
#[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_proration_date: Option<Timestamp>,
#[serde(skip_serializing_if = "Option::is_none")]
pub subtotal: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tax: Option<i64>,
#[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_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", ¶ms)
}
pub fn create(client: &Client, params: CreateInvoice<'_>) -> Response<Invoice> {
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, Deserialize, Serialize)]
pub struct DiscountsResourceDiscountAmount {
pub amount: i64,
pub discount: Expandable<Discount>,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct InvoiceSettingCustomField {
pub name: String,
pub value: String,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct TaxAmount {
pub amount: i64,
pub inclusive: bool,
pub tax_rate: Expandable<TaxRate>,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct InvoiceThresholdReason {
#[serde(skip_serializing_if = "Option::is_none")]
pub amount_gte: Option<i64>,
pub item_reasons: Vec<InvoiceItemThresholdReason>,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct InvoiceItemThresholdReason {
pub line_item_ids: Vec<String>,
pub usage_gte: i64,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct InvoiceTransferData {
#[serde(skip_serializing_if = "Option::is_none")]
pub amount: Option<i64>,
pub destination: Expandable<Account>,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct InvoicesPaymentSettings {
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method_options: Option<InvoicesPaymentMethodOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method_types: Option<Vec<InvoicesPaymentSettingsPaymentMethodTypes>>,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct InvoicesPaymentMethodOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub bancontact: Option<InvoicePaymentMethodOptionsBancontact>,
#[serde(skip_serializing_if = "Option::is_none")]
pub card: Option<InvoicePaymentMethodOptionsCard>,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct InvoicePaymentMethodOptionsBancontact {
pub preferred_language: InvoicePaymentMethodOptionsBancontactPreferredLanguage,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct InvoicePaymentMethodOptionsCard {
#[serde(skip_serializing_if = "Option::is_none")]
pub request_three_d_secure: Option<InvoicePaymentMethodOptionsCardRequestThreeDSecure>,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct InvoicesResourceInvoiceTaxId {
#[serde(rename = "type")]
pub type_: TaxIdType,
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct InvoicesStatusTransitions {
#[serde(skip_serializing_if = "Option::is_none")]
pub finalized_at: Option<Timestamp>,
#[serde(skip_serializing_if = "Option::is_none")]
pub marked_uncollectible_at: Option<Timestamp>,
#[serde(skip_serializing_if = "Option::is_none")]
pub paid_at: Option<Timestamp>,
#[serde(skip_serializing_if = "Option::is_none")]
pub voided_at: Option<Timestamp>,
}
#[derive(Clone, Debug, Serialize)]
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 collection_method: Option<CollectionMethod>,
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_fields: Option<Vec<CustomField>>,
pub customer: 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 = "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 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 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(customer: CustomerId) -> Self {
CreateInvoice {
account_tax_ids: Default::default(),
application_fee_amount: Default::default(),
auto_advance: Default::default(),
collection_method: Default::default(),
custom_fields: Default::default(),
customer,
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(),
expand: Default::default(),
footer: Default::default(),
metadata: Default::default(),
on_behalf_of: Default::default(),
payment_settings: 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<InvoiceStatusFilter>,
#[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(),
}
}
}
#[derive(Clone, Debug, 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, Deserialize, Serialize)]
pub struct CreateInvoicePaymentSettings {
#[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, Deserialize, Serialize)]
pub struct CreateInvoiceTransferData {
#[serde(skip_serializing_if = "Option::is_none")]
pub amount: Option<i64>,
pub destination: String,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct CreateInvoicePaymentSettingsPaymentMethodOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub bancontact: Option<CreateInvoicePaymentSettingsPaymentMethodOptionsBancontact>,
#[serde(skip_serializing_if = "Option::is_none")]
pub card: Option<CreateInvoicePaymentSettingsPaymentMethodOptionsCard>,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct CreateInvoicePaymentSettingsPaymentMethodOptionsBancontact {
#[serde(skip_serializing_if = "Option::is_none")]
pub preferred_language:
Option<CreateInvoicePaymentSettingsPaymentMethodOptionsBancontactPreferredLanguage>,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct CreateInvoicePaymentSettingsPaymentMethodOptionsCard {
#[serde(skip_serializing_if = "Option::is_none")]
pub request_three_d_secure:
Option<CreateInvoicePaymentSettingsPaymentMethodOptionsCardRequestThreeDSecure>,
}
#[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)
}
}
#[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)
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateInvoicePaymentSettingsPaymentMethodOptionsCardRequestThreeDSecure {
Any,
Automatic,
}
impl CreateInvoicePaymentSettingsPaymentMethodOptionsCardRequestThreeDSecure {
pub fn as_str(self) -> &'static str {
match self {
CreateInvoicePaymentSettingsPaymentMethodOptionsCardRequestThreeDSecure::Any => "any",
CreateInvoicePaymentSettingsPaymentMethodOptionsCardRequestThreeDSecure::Automatic => {
"automatic"
}
}
}
}
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)
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateInvoicePaymentSettingsPaymentMethodTypes {
AchCreditTransfer,
AchDebit,
AuBecsDebit,
BacsDebit,
Bancontact,
Card,
Fpx,
Giropay,
Ideal,
SepaDebit,
Sofort,
}
impl CreateInvoicePaymentSettingsPaymentMethodTypes {
pub fn as_str(self) -> &'static str {
match self {
CreateInvoicePaymentSettingsPaymentMethodTypes::AchCreditTransfer => {
"ach_credit_transfer"
}
CreateInvoicePaymentSettingsPaymentMethodTypes::AchDebit => "ach_debit",
CreateInvoicePaymentSettingsPaymentMethodTypes::AuBecsDebit => "au_becs_debit",
CreateInvoicePaymentSettingsPaymentMethodTypes::BacsDebit => "bacs_debit",
CreateInvoicePaymentSettingsPaymentMethodTypes::Bancontact => "bancontact",
CreateInvoicePaymentSettingsPaymentMethodTypes::Card => "card",
CreateInvoicePaymentSettingsPaymentMethodTypes::Fpx => "fpx",
CreateInvoicePaymentSettingsPaymentMethodTypes::Giropay => "giropay",
CreateInvoicePaymentSettingsPaymentMethodTypes::Ideal => "ideal",
CreateInvoicePaymentSettingsPaymentMethodTypes::SepaDebit => "sepa_debit",
CreateInvoicePaymentSettingsPaymentMethodTypes::Sofort => "sofort",
}
}
}
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)
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum InvoiceBillingReason {
AutomaticPendingInvoiceItemInvoice,
Manual,
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::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)
}
}
#[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)
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum InvoicePaymentMethodOptionsBancontactPreferredLanguage {
De,
En,
Fr,
Nl,
}
impl InvoicePaymentMethodOptionsBancontactPreferredLanguage {
pub fn as_str(self) -> &'static str {
match self {
InvoicePaymentMethodOptionsBancontactPreferredLanguage::De => "de",
InvoicePaymentMethodOptionsBancontactPreferredLanguage::En => "en",
InvoicePaymentMethodOptionsBancontactPreferredLanguage::Fr => "fr",
InvoicePaymentMethodOptionsBancontactPreferredLanguage::Nl => "nl",
}
}
}
impl AsRef<str> for InvoicePaymentMethodOptionsBancontactPreferredLanguage {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for InvoicePaymentMethodOptionsBancontactPreferredLanguage {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum InvoicePaymentMethodOptionsCardRequestThreeDSecure {
Any,
Automatic,
}
impl InvoicePaymentMethodOptionsCardRequestThreeDSecure {
pub fn as_str(self) -> &'static str {
match self {
InvoicePaymentMethodOptionsCardRequestThreeDSecure::Any => "any",
InvoicePaymentMethodOptionsCardRequestThreeDSecure::Automatic => "automatic",
}
}
}
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)
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum InvoiceStatus {
Deleted,
Draft,
Open,
Paid,
Uncollectible,
Void,
}
impl InvoiceStatus {
pub fn as_str(self) -> &'static str {
match self {
InvoiceStatus::Deleted => "deleted",
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)
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum InvoiceStatusFilter {
Draft,
Open,
Paid,
Uncollectible,
Void,
}
impl InvoiceStatusFilter {
pub fn as_str(self) -> &'static str {
match self {
InvoiceStatusFilter::Draft => "draft",
InvoiceStatusFilter::Open => "open",
InvoiceStatusFilter::Paid => "paid",
InvoiceStatusFilter::Uncollectible => "uncollectible",
InvoiceStatusFilter::Void => "void",
}
}
}
impl AsRef<str> for InvoiceStatusFilter {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for InvoiceStatusFilter {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum InvoicesPaymentSettingsPaymentMethodTypes {
AchCreditTransfer,
AchDebit,
AuBecsDebit,
BacsDebit,
Bancontact,
Card,
Fpx,
Giropay,
Ideal,
SepaDebit,
Sofort,
}
impl InvoicesPaymentSettingsPaymentMethodTypes {
pub fn as_str(self) -> &'static str {
match self {
InvoicesPaymentSettingsPaymentMethodTypes::AchCreditTransfer => "ach_credit_transfer",
InvoicesPaymentSettingsPaymentMethodTypes::AchDebit => "ach_debit",
InvoicesPaymentSettingsPaymentMethodTypes::AuBecsDebit => "au_becs_debit",
InvoicesPaymentSettingsPaymentMethodTypes::BacsDebit => "bacs_debit",
InvoicesPaymentSettingsPaymentMethodTypes::Bancontact => "bancontact",
InvoicesPaymentSettingsPaymentMethodTypes::Card => "card",
InvoicesPaymentSettingsPaymentMethodTypes::Fpx => "fpx",
InvoicesPaymentSettingsPaymentMethodTypes::Giropay => "giropay",
InvoicesPaymentSettingsPaymentMethodTypes::Ideal => "ideal",
InvoicesPaymentSettingsPaymentMethodTypes::SepaDebit => "sepa_debit",
InvoicesPaymentSettingsPaymentMethodTypes::Sofort => "sofort",
}
}
}
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)
}
}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum TaxIdType {
AeTrn,
AuAbn,
BrCnpj,
BrCpf,
CaBn,
CaQst,
ChVat,
ClTin,
EsCif,
EuVat,
GbVat,
HkBr,
IdNpwp,
InGst,
JpCn,
JpRn,
KrBrn,
LiUid,
MxRfc,
MyFrp,
MyItn,
MySst,
NoVat,
NzGst,
RuInn,
RuKpp,
SaVat,
SgGst,
SgUen,
ThVat,
TwVat,
Unknown,
UsEin,
ZaVat,
}
impl TaxIdType {
pub fn as_str(self) -> &'static str {
match self {
TaxIdType::AeTrn => "ae_trn",
TaxIdType::AuAbn => "au_abn",
TaxIdType::BrCnpj => "br_cnpj",
TaxIdType::BrCpf => "br_cpf",
TaxIdType::CaBn => "ca_bn",
TaxIdType::CaQst => "ca_qst",
TaxIdType::ChVat => "ch_vat",
TaxIdType::ClTin => "cl_tin",
TaxIdType::EsCif => "es_cif",
TaxIdType::EuVat => "eu_vat",
TaxIdType::GbVat => "gb_vat",
TaxIdType::HkBr => "hk_br",
TaxIdType::IdNpwp => "id_npwp",
TaxIdType::InGst => "in_gst",
TaxIdType::JpCn => "jp_cn",
TaxIdType::JpRn => "jp_rn",
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::RuInn => "ru_inn",
TaxIdType::RuKpp => "ru_kpp",
TaxIdType::SaVat => "sa_vat",
TaxIdType::SgGst => "sg_gst",
TaxIdType::SgUen => "sg_uen",
TaxIdType::ThVat => "th_vat",
TaxIdType::TwVat => "tw_vat",
TaxIdType::Unknown => "unknown",
TaxIdType::UsEin => "us_ein",
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)
}
}