#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
pub struct BillingProfileResponse {
#[serde(rename = "billing_profile")]
pub billing_profile: BillingProfile,
}
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
pub struct BillingProfile {
#[serde(rename = "customer_type")]
pub customer_type: BillingProfileCustomerType,
#[serde(rename = "company_name")]
pub company_name: String,
#[serde(rename = "tax_id")]
pub tax_id: String,
#[serde(rename = "tax_id_kind")]
pub tax_id_kind: String,
#[serde(rename = "no_tax_id_reason")]
pub no_tax_id_reason: String,
#[serde(rename = "email")]
pub email: String,
#[serde(rename = "phone")]
pub phone: String,
#[serde(rename = "country")]
pub country: ResourceRef,
#[serde(rename = "state")]
pub state: BillingProfileState,
#[serde(rename = "city")]
pub city: BillingProfileCity,
#[serde(rename = "address")]
pub address: BillingAddress,
#[serde(rename = "ready")]
pub ready: bool,
#[serde(rename = "missing_fields")]
pub missing_fields: Vec<String>,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum BillingProfileCustomerType {
Value,
Individual,
Company,
Unknown(String),
}
impl BillingProfileCustomerType {
pub fn as_str(&self) -> &str {
match self {
Self::Value => "",
Self::Individual => "individual",
Self::Company => "company",
Self::Unknown(value) => value,
}
}
}
impl serde::Serialize for BillingProfileCustomerType {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for BillingProfileCustomerType {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let value = <String as serde::Deserialize>::deserialize(deserializer)?;
Ok(match value.as_str() {
"" => Self::Value,
"individual" => Self::Individual,
"company" => Self::Company,
_ => Self::Unknown(value),
})
}
}
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
pub struct ResourceRef {
#[serde(rename = "id")]
pub id: String,
#[serde(rename = "crn")]
pub crn: String,
#[serde(rename = "name", default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
#[serde(untagged)]
pub enum BillingProfileState {
Variant1(Box<ResourceRef>),
Variant2(Box<crate::Nullable<serde_json::Value>>),
}
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
#[serde(untagged)]
pub enum BillingProfileCity {
Variant1(Box<ResourceRef>),
Variant2(Box<crate::Nullable<serde_json::Value>>),
}
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
pub struct BillingAddress {
#[serde(
rename = "street_name",
default,
skip_serializing_if = "Option::is_none"
)]
pub street_name: Option<String>,
#[serde(
rename = "street_number",
default,
skip_serializing_if = "Option::is_none"
)]
pub street_number: Option<String>,
#[serde(
rename = "complement",
default,
skip_serializing_if = "Option::is_none"
)]
pub complement: Option<String>,
#[serde(
rename = "neighborhood",
default,
skip_serializing_if = "Option::is_none"
)]
pub neighborhood: Option<String>,
#[serde(rename = "city", default, skip_serializing_if = "Option::is_none")]
pub city: Option<String>,
#[serde(rename = "state", default, skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(
rename = "postal_code",
default,
skip_serializing_if = "Option::is_none"
)]
pub postal_code: Option<String>,
}
pub type GetBillingProfileResponse = BillingProfileResponse;
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
pub struct CurrentUsage {
#[serde(rename = "amount")]
pub amount: String,
#[serde(rename = "period_start")]
pub period_start: String,
#[serde(rename = "items")]
pub items: Vec<UsageLine>,
#[serde(rename = "included_usage")]
pub included_usage: Vec<IncludedUsage>,
}
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
pub struct UsageLine {
#[serde(rename = "sku")]
pub sku: String,
#[serde(rename = "description")]
pub description: String,
#[serde(rename = "quantity")]
pub quantity: String,
#[serde(rename = "unit")]
pub unit: String,
#[serde(rename = "amount")]
pub amount: String,
}
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
pub struct IncludedUsage {
#[serde(rename = "code")]
pub code: String,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "unit")]
pub unit: String,
#[serde(rename = "period_start")]
pub period_start: String,
#[serde(rename = "period_end")]
pub period_end: String,
#[serde(rename = "counted_from")]
pub counted_from: String,
#[serde(rename = "base")]
pub base: String,
#[serde(rename = "contributed")]
pub contributed: String,
#[serde(rename = "total")]
pub total: String,
#[serde(rename = "used")]
pub used: String,
#[serde(rename = "included_used")]
pub included_used: String,
#[serde(rename = "remaining")]
pub remaining: String,
#[serde(rename = "overage")]
pub overage: String,
}
pub type GetCurrentUsageResponse = CurrentUsage;
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
pub struct InvoiceResponse {
#[serde(rename = "invoice")]
pub invoice: Invoice,
}
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
pub struct Invoice {
#[serde(rename = "crn")]
pub crn: String,
#[serde(rename = "id")]
pub id: String,
#[serde(rename = "invoice_number")]
pub invoice_number: String,
#[serde(rename = "period_start")]
pub period_start: String,
#[serde(rename = "period_end")]
pub period_end: String,
#[serde(rename = "subtotal")]
pub subtotal: String,
#[serde(rename = "credits_applied")]
pub credits_applied: String,
#[serde(rename = "total")]
pub total: String,
#[serde(rename = "currency")]
pub currency: String,
#[serde(rename = "refunded_amount")]
pub refunded_amount: String,
#[serde(rename = "disputed_amount")]
pub disputed_amount: String,
#[serde(rename = "status")]
pub status: InvoiceStatus,
#[serde(
rename = "issued_at",
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "crate::response::present_nullable"
)]
pub issued_at: Option<crate::Nullable<String>>,
#[serde(
rename = "due_at",
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "crate::response::present_nullable"
)]
pub due_at: Option<crate::Nullable<String>>,
#[serde(
rename = "paid_at",
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "crate::response::present_nullable"
)]
pub paid_at: Option<crate::Nullable<String>>,
#[serde(rename = "created_at")]
pub created_at: String,
#[serde(rename = "pdf_url", default, skip_serializing_if = "Option::is_none")]
pub pdf_url: Option<String>,
#[serde(rename = "items", default, skip_serializing_if = "Option::is_none")]
pub items: Option<Vec<InvoiceItem>>,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum InvoiceStatus {
Open,
Paid,
PastDue,
Uncollectible,
Void,
Unknown(String),
}
impl InvoiceStatus {
pub fn as_str(&self) -> &str {
match self {
Self::Open => "open",
Self::Paid => "paid",
Self::PastDue => "past_due",
Self::Uncollectible => "uncollectible",
Self::Void => "void",
Self::Unknown(value) => value,
}
}
}
impl serde::Serialize for InvoiceStatus {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for InvoiceStatus {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let value = <String as serde::Deserialize>::deserialize(deserializer)?;
Ok(match value.as_str() {
"open" => Self::Open,
"paid" => Self::Paid,
"past_due" => Self::PastDue,
"uncollectible" => Self::Uncollectible,
"void" => Self::Void,
_ => Self::Unknown(value),
})
}
}
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
pub struct InvoiceItem {
#[serde(rename = "kind")]
pub kind: InvoiceItemKind,
#[serde(
rename = "sku",
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "crate::response::present_nullable"
)]
pub sku: Option<crate::Nullable<String>>,
#[serde(rename = "description")]
pub description: String,
#[serde(rename = "quantity")]
pub quantity: String,
#[serde(
rename = "unit",
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "crate::response::present_nullable"
)]
pub unit: Option<crate::Nullable<String>>,
#[serde(rename = "unit_price")]
pub unit_price: String,
#[serde(rename = "amount")]
pub amount: String,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum InvoiceItemKind {
Usage,
Credit,
Unknown(String),
}
impl InvoiceItemKind {
pub fn as_str(&self) -> &str {
match self {
Self::Usage => "usage",
Self::Credit => "credit",
Self::Unknown(value) => value,
}
}
}
impl serde::Serialize for InvoiceItemKind {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for InvoiceItemKind {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let value = <String as serde::Deserialize>::deserialize(deserializer)?;
Ok(match value.as_str() {
"usage" => Self::Usage,
"credit" => Self::Credit,
_ => Self::Unknown(value),
})
}
}
pub type GetInvoiceResponse = InvoiceResponse;
pub type GetInvoiceResource = Invoice;
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
pub struct GetInvoiceScope {
#[serde(rename = "limit", default, skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
}
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
pub struct ListCreditsParameters {
#[serde(rename = "crn", default, skip_serializing_if = "Option::is_none")]
pub crn: Option<String>,
#[serde(rename = "marker", default, skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "limit", default, skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
}
pub type ListCreditsQuery = ListCreditsParameters;
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
pub struct CreditListResponse {
#[serde(rename = "credits")]
pub credits: Vec<Credit>,
#[serde(rename = "meta")]
pub meta: PaginationMeta,
}
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
pub struct Credit {
#[serde(rename = "crn")]
pub crn: String,
#[serde(rename = "id")]
pub id: String,
#[serde(rename = "source")]
pub source: CreditSource,
#[serde(rename = "description")]
pub description: String,
#[serde(rename = "amount")]
pub amount: String,
#[serde(rename = "remaining")]
pub remaining: String,
#[serde(
rename = "expires_at",
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "crate::response::present_nullable"
)]
pub expires_at: Option<crate::Nullable<String>>,
#[serde(rename = "created_at")]
pub created_at: String,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum CreditSource {
Promo,
Coupon,
Adjustment,
Migration,
Unknown(String),
}
impl CreditSource {
pub fn as_str(&self) -> &str {
match self {
Self::Promo => "promo",
Self::Coupon => "coupon",
Self::Adjustment => "adjustment",
Self::Migration => "migration",
Self::Unknown(value) => value,
}
}
}
impl serde::Serialize for CreditSource {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for CreditSource {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let value = <String as serde::Deserialize>::deserialize(deserializer)?;
Ok(match value.as_str() {
"promo" => Self::Promo,
"coupon" => Self::Coupon,
"adjustment" => Self::Adjustment,
"migration" => Self::Migration,
_ => Self::Unknown(value),
})
}
}
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
pub struct PaginationMeta {
#[serde(rename = "total", default, skip_serializing_if = "Option::is_none")]
pub total: Option<i64>,
#[serde(rename = "limit", default, skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "marker", default, skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "has_more", default, skip_serializing_if = "Option::is_none")]
pub has_more: Option<bool>,
}
pub type ListCreditsResponse = CreditListResponse;
pub type ListCreditsItem = Credit;
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
pub struct ListFiscalInvoicesParameters {
#[serde(rename = "invoice", default, skip_serializing_if = "Option::is_none")]
pub invoice: Option<String>,
#[serde(rename = "limit", default, skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "marker", default, skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
}
pub type ListFiscalInvoicesQuery = ListFiscalInvoicesParameters;
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
pub struct FiscalInvoiceListResponse {
#[serde(rename = "fiscal_invoices")]
pub fiscal_invoices: Vec<FiscalInvoice>,
#[serde(rename = "meta")]
pub meta: PaginationMeta,
}
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
pub struct FiscalInvoice {
#[serde(rename = "id")]
pub id: String,
#[serde(rename = "amount")]
pub amount: String,
#[serde(rename = "number")]
pub number: String,
#[serde(rename = "verification_code")]
pub verification_code: String,
#[serde(rename = "url")]
pub url: String,
#[serde(rename = "issued_at")]
pub issued_at: crate::Nullable<String>,
#[serde(rename = "created_at")]
pub created_at: String,
#[serde(rename = "crn")]
pub crn: String,
#[serde(rename = "payment")]
pub payment: ResourceRef,
#[serde(rename = "invoice")]
pub invoice: FiscalInvoiceInvoice,
}
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
#[serde(untagged)]
pub enum FiscalInvoiceInvoice {
Variant1(Box<ResourceRef>),
Variant2(Box<crate::Nullable<serde_json::Value>>),
}
pub type ListFiscalInvoicesResponse = FiscalInvoiceListResponse;
pub type ListFiscalInvoicesItem = FiscalInvoice;
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
pub struct ListInvoicesParameters {
#[serde(rename = "crn", default, skip_serializing_if = "Option::is_none")]
pub crn: Option<String>,
#[serde(rename = "marker", default, skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "limit", default, skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
}
pub type ListInvoicesQuery = ListInvoicesParameters;
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
pub struct InvoiceListResponse {
#[serde(rename = "invoices")]
pub invoices: Vec<Invoice>,
#[serde(rename = "meta")]
pub meta: PaginationMeta,
}
pub type ListInvoicesResponse = InvoiceListResponse;
pub type ListInvoicesItem = Invoice;
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
pub struct ListPaymentsParameters {
#[serde(rename = "crn", default, skip_serializing_if = "Option::is_none")]
pub crn: Option<String>,
#[serde(rename = "marker", default, skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "limit", default, skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
}
pub type ListPaymentsQuery = ListPaymentsParameters;
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
pub struct PaymentListResponse {
#[serde(rename = "payments")]
pub payments: Vec<Payment>,
#[serde(rename = "meta")]
pub meta: PaginationMeta,
}
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
pub struct Payment {
#[serde(rename = "crn")]
pub crn: String,
#[serde(rename = "id")]
pub id: String,
#[serde(rename = "invoice")]
pub invoice: PaymentInvoice,
#[serde(rename = "amount")]
pub amount: String,
#[serde(rename = "refunded_amount")]
pub refunded_amount: String,
#[serde(rename = "disputed_amount")]
pub disputed_amount: String,
#[serde(rename = "retained_amount")]
pub retained_amount: String,
#[serde(rename = "status")]
pub status: PaymentStatus,
#[serde(rename = "attempt")]
pub attempt: i64,
#[serde(
rename = "completed_at",
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "crate::response::present_nullable"
)]
pub completed_at: Option<crate::Nullable<String>>,
#[serde(rename = "created_at")]
pub created_at: String,
}
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
#[serde(untagged)]
pub enum PaymentInvoice {
Variant1(Box<ResourceRef>),
Variant2(Box<crate::Nullable<serde_json::Value>>),
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum PaymentStatus {
Pending,
Processing,
Succeeded,
Failed,
Refunded,
Unknown(String),
}
impl PaymentStatus {
pub fn as_str(&self) -> &str {
match self {
Self::Pending => "pending",
Self::Processing => "processing",
Self::Succeeded => "succeeded",
Self::Failed => "failed",
Self::Refunded => "refunded",
Self::Unknown(value) => value,
}
}
}
impl serde::Serialize for PaymentStatus {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for PaymentStatus {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let value = <String as serde::Deserialize>::deserialize(deserializer)?;
Ok(match value.as_str() {
"pending" => Self::Pending,
"processing" => Self::Processing,
"succeeded" => Self::Succeeded,
"failed" => Self::Failed,
"refunded" => Self::Refunded,
_ => Self::Unknown(value),
})
}
}
pub type ListPaymentsResponse = PaymentListResponse;
pub type ListPaymentsItem = Payment;
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
pub struct ListPricesParameters {
#[serde(rename = "service", default, skip_serializing_if = "Option::is_none")]
pub service: Option<String>,
#[serde(
rename = "resource_type",
default,
skip_serializing_if = "Option::is_none"
)]
pub resource_type: Option<String>,
#[serde(rename = "sku", default, skip_serializing_if = "Option::is_none")]
pub sku: Option<String>,
#[serde(rename = "family", default, skip_serializing_if = "Option::is_none")]
pub family: Option<String>,
#[serde(rename = "at", default, skip_serializing_if = "Option::is_none")]
pub at: Option<String>,
}
pub type ListPricesQuery = ListPricesParameters;
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
pub struct PriceListResponse {
#[serde(rename = "prices")]
pub prices: Vec<Price>,
#[serde(rename = "as_of")]
pub as_of: String,
}
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
pub struct Price {
#[serde(rename = "sku")]
pub sku: String,
#[serde(rename = "service")]
pub service: String,
#[serde(rename = "resource_type")]
pub resource_type: String,
#[serde(rename = "name")]
pub name: String,
#[serde(
rename = "description",
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "crate::response::present_nullable"
)]
pub description: Option<crate::Nullable<String>>,
#[serde(rename = "unit")]
pub unit: String,
#[serde(rename = "unit_price")]
pub unit_price: String,
#[serde(rename = "currency")]
pub currency: String,
#[serde(rename = "metadata")]
pub metadata: std::collections::BTreeMap<String, serde_json::Value>,
#[serde(
rename = "included_usage",
default,
skip_serializing_if = "Option::is_none"
)]
pub included_usage: Option<Vec<CatalogAllowance>>,
}
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
pub struct CatalogAllowance {
#[serde(rename = "policy_code")]
pub policy_code: String,
#[serde(rename = "unit")]
pub unit: String,
#[serde(rename = "monthly_quantity")]
pub monthly_quantity: String,
#[serde(rename = "monthly_base")]
pub monthly_base: String,
}
pub type ListPricesResponse = PriceListResponse;
pub type ListPricesItem = Price;
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
pub struct ListTransactionsParameters {
#[serde(rename = "crn", default, skip_serializing_if = "Option::is_none")]
pub crn: Option<String>,
#[serde(rename = "marker", default, skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "limit", default, skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
}
pub type ListTransactionsQuery = ListTransactionsParameters;
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
pub struct TransactionListResponse {
#[serde(rename = "transactions")]
pub transactions: Vec<Transaction>,
#[serde(rename = "meta")]
pub meta: PaginationMeta,
}
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
pub struct Transaction {
#[serde(rename = "crn")]
pub crn: String,
#[serde(rename = "id")]
pub id: String,
#[serde(rename = "type")]
pub type_: TransactionType,
#[serde(rename = "amount")]
pub amount: String,
#[serde(
rename = "description",
default,
skip_serializing_if = "Option::is_none",
deserialize_with = "crate::response::present_nullable"
)]
pub description: Option<crate::Nullable<String>>,
#[serde(rename = "reference")]
pub reference: TransactionReference,
#[serde(rename = "created_at")]
pub created_at: String,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum TransactionType {
Payment,
Refund,
RefundReversal,
Dispute,
DisputeReversal,
Adjustment,
CreditGrant,
CreditApplied,
Unknown(String),
}
impl TransactionType {
pub fn as_str(&self) -> &str {
match self {
Self::Payment => "payment",
Self::Refund => "refund",
Self::RefundReversal => "refund_reversal",
Self::Dispute => "dispute",
Self::DisputeReversal => "dispute_reversal",
Self::Adjustment => "adjustment",
Self::CreditGrant => "credit_grant",
Self::CreditApplied => "credit_applied",
Self::Unknown(value) => value,
}
}
}
impl serde::Serialize for TransactionType {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for TransactionType {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let value = <String as serde::Deserialize>::deserialize(deserializer)?;
Ok(match value.as_str() {
"payment" => Self::Payment,
"refund" => Self::Refund,
"refund_reversal" => Self::RefundReversal,
"dispute" => Self::Dispute,
"dispute_reversal" => Self::DisputeReversal,
"adjustment" => Self::Adjustment,
"credit_grant" => Self::CreditGrant,
"credit_applied" => Self::CreditApplied,
_ => Self::Unknown(value),
})
}
}
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
#[serde(untagged)]
pub enum TransactionReference {
Variant1(Box<ResourceRef>),
Variant2(Box<crate::Nullable<serde_json::Value>>),
}
pub type ListTransactionsResponse = TransactionListResponse;
pub type ListTransactionsItem = Transaction;
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
pub struct BillingProfileUpdateInput {
#[serde(
rename = "customer_type",
default,
skip_serializing_if = "Option::is_none"
)]
pub customer_type: Option<BillingProfileUpdateInputCustomerType>,
#[serde(
rename = "company_name",
default,
skip_serializing_if = "Option::is_none"
)]
pub company_name: Option<String>,
#[serde(rename = "tax_id", default, skip_serializing_if = "Option::is_none")]
pub tax_id: Option<String>,
#[serde(
rename = "tax_id_kind",
default,
skip_serializing_if = "Option::is_none"
)]
pub tax_id_kind: Option<String>,
#[serde(
rename = "no_tax_id_reason",
default,
skip_serializing_if = "Option::is_none"
)]
pub no_tax_id_reason: Option<String>,
#[serde(rename = "email", default, skip_serializing_if = "Option::is_none")]
pub email: Option<String>,
#[serde(rename = "phone", default, skip_serializing_if = "Option::is_none")]
pub phone: Option<String>,
#[serde(rename = "country", default, skip_serializing_if = "Option::is_none")]
pub country: Option<String>,
#[serde(rename = "state", default, skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "city", default, skip_serializing_if = "Option::is_none")]
pub city: Option<String>,
#[serde(rename = "address", default, skip_serializing_if = "Option::is_none")]
pub address: Option<BillingAddressInput>,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum BillingProfileUpdateInputCustomerType {
Value,
Individual,
Company,
Unknown(String),
}
impl BillingProfileUpdateInputCustomerType {
pub fn as_str(&self) -> &str {
match self {
Self::Value => "",
Self::Individual => "individual",
Self::Company => "company",
Self::Unknown(value) => value,
}
}
}
impl serde::Serialize for BillingProfileUpdateInputCustomerType {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for BillingProfileUpdateInputCustomerType {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let value = <String as serde::Deserialize>::deserialize(deserializer)?;
Ok(match value.as_str() {
"" => Self::Value,
"individual" => Self::Individual,
"company" => Self::Company,
_ => Self::Unknown(value),
})
}
}
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
pub struct BillingAddressInput {
#[serde(
rename = "street_name",
default,
skip_serializing_if = "Option::is_none"
)]
pub street_name: Option<String>,
#[serde(
rename = "street_number",
default,
skip_serializing_if = "Option::is_none"
)]
pub street_number: Option<String>,
#[serde(
rename = "complement",
default,
skip_serializing_if = "Option::is_none"
)]
pub complement: Option<String>,
#[serde(
rename = "neighborhood",
default,
skip_serializing_if = "Option::is_none"
)]
pub neighborhood: Option<String>,
#[serde(rename = "city", default, skip_serializing_if = "Option::is_none")]
pub city: Option<String>,
#[serde(rename = "state", default, skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(
rename = "postal_code",
default,
skip_serializing_if = "Option::is_none"
)]
pub postal_code: Option<String>,
}
pub type UpdateBillingProfileBody = BillingProfileUpdateInput;
pub type UpdateBillingProfileResponse = BillingProfileResponse;