use crate::config::{Client, Response};
use crate::ids::{CustomerId, PaymentMethodId, SetupIntentId};
use crate::params::{Expand, Expandable, List, Metadata, Object, RangeQuery, Timestamp};
use crate::resources::{
Account, ApiErrors, Application, Currency, Customer, Mandate, PaymentMethod, SetupAttempt,
};
use serde_derive::{Deserialize, Serialize};
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct SetupIntent {
pub id: SetupIntentId,
#[serde(skip_serializing_if = "Option::is_none")]
pub application: Option<Expandable<Application>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub cancellation_reason: Option<SetupIntentCancellationReason>,
#[serde(skip_serializing_if = "Option::is_none")]
pub client_secret: Option<String>,
pub created: Timestamp,
#[serde(skip_serializing_if = "Option::is_none")]
pub customer: Option<Expandable<Customer>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub last_setup_error: Option<ApiErrors>,
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_attempt: Option<Expandable<SetupAttempt>>,
pub livemode: bool,
#[serde(skip_serializing_if = "Option::is_none")]
pub mandate: Option<Expandable<Mandate>>,
#[serde(default)]
pub metadata: Metadata,
#[serde(skip_serializing_if = "Option::is_none")]
pub next_action: Option<SetupIntentNextAction>,
#[serde(skip_serializing_if = "Option::is_none")]
pub on_behalf_of: Option<Expandable<Account>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method: Option<Expandable<PaymentMethod>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method_options: Option<SetupIntentPaymentMethodOptions>,
pub payment_method_types: Vec<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub single_use_mandate: Option<Expandable<Mandate>>,
pub status: SetupIntentStatus,
pub usage: String,
}
impl SetupIntent {
pub fn list(client: &Client, params: ListSetupIntents<'_>) -> Response<List<SetupIntent>> {
client.get_query("/setup_intents", ¶ms)
}
pub fn create(client: &Client, params: CreateSetupIntent<'_>) -> Response<SetupIntent> {
client.post_form("/setup_intents", ¶ms)
}
pub fn retrieve(client: &Client, id: &SetupIntentId, expand: &[&str]) -> Response<SetupIntent> {
client.get_query(&format!("/setup_intents/{}", id), &Expand { expand })
}
pub fn update(
client: &Client,
id: &SetupIntentId,
params: UpdateSetupIntent<'_>,
) -> Response<SetupIntent> {
client.post_form(&format!("/setup_intents/{}", id), ¶ms)
}
}
impl Object for SetupIntent {
type Id = SetupIntentId;
fn id(&self) -> Self::Id {
self.id.clone()
}
fn object(&self) -> &'static str {
"setup_intent"
}
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct SetupIntentNextAction {
#[serde(skip_serializing_if = "Option::is_none")]
pub redirect_to_url: Option<SetupIntentNextActionRedirectToUrl>,
#[serde(rename = "type")]
pub type_: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub use_stripe_sdk: Option<serde_json::Value>,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct SetupIntentNextActionRedirectToUrl {
#[serde(skip_serializing_if = "Option::is_none")]
pub return_url: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub url: Option<String>,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct SetupIntentPaymentMethodOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub card: Option<SetupIntentPaymentMethodOptionsCard>,
#[serde(skip_serializing_if = "Option::is_none")]
pub sepa_debit: Option<SetupIntentPaymentMethodOptionsSepaDebit>,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct SetupIntentPaymentMethodOptionsCard {
#[serde(skip_serializing_if = "Option::is_none")]
pub request_three_d_secure: Option<SetupIntentPaymentMethodOptionsCardRequestThreeDSecure>,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct SetupIntentPaymentMethodOptionsSepaDebit {
#[serde(skip_serializing_if = "Option::is_none")]
pub mandate_options: Option<SetupIntentPaymentMethodOptionsMandateOptionsSepaDebit>,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct SetupIntentPaymentMethodOptionsMandateOptionsSepaDebit {}
#[derive(Clone, Debug, Serialize, Default)]
pub struct CreateSetupIntent<'a> {
#[serde(skip_serializing_if = "Option::is_none")]
pub confirm: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub customer: Option<CustomerId>,
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<&'a str>,
#[serde(skip_serializing_if = "Expand::is_empty")]
pub expand: &'a [&'a str],
#[serde(skip_serializing_if = "Option::is_none")]
pub mandate_data: Option<CreateSetupIntentMandateData>,
#[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_method: Option<PaymentMethodId>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method_options: Option<CreateSetupIntentPaymentMethodOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method_types: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub return_url: Option<&'a str>,
#[serde(skip_serializing_if = "Option::is_none")]
pub single_use: Option<CreateSetupIntentSingleUse>,
}
impl<'a> CreateSetupIntent<'a> {
pub fn new() -> Self {
CreateSetupIntent {
confirm: Default::default(),
customer: Default::default(),
description: Default::default(),
expand: Default::default(),
mandate_data: Default::default(),
metadata: Default::default(),
on_behalf_of: Default::default(),
payment_method: Default::default(),
payment_method_options: Default::default(),
payment_method_types: Default::default(),
return_url: Default::default(),
single_use: Default::default(),
}
}
}
#[derive(Clone, Debug, Serialize, Default)]
pub struct ListSetupIntents<'a> {
#[serde(skip_serializing_if = "Option::is_none")]
pub created: Option<RangeQuery<Timestamp>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub customer: Option<CustomerId>,
#[serde(skip_serializing_if = "Option::is_none")]
pub ending_before: Option<SetupIntentId>,
#[serde(skip_serializing_if = "Expand::is_empty")]
pub expand: &'a [&'a str],
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<u64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method: Option<PaymentMethodId>,
#[serde(skip_serializing_if = "Option::is_none")]
pub starting_after: Option<SetupIntentId>,
}
impl<'a> ListSetupIntents<'a> {
pub fn new() -> Self {
ListSetupIntents {
created: Default::default(),
customer: Default::default(),
ending_before: Default::default(),
expand: Default::default(),
limit: Default::default(),
payment_method: Default::default(),
starting_after: Default::default(),
}
}
}
#[derive(Clone, Debug, Serialize, Default)]
pub struct UpdateSetupIntent<'a> {
#[serde(skip_serializing_if = "Option::is_none")]
pub customer: Option<CustomerId>,
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<&'a str>,
#[serde(skip_serializing_if = "Expand::is_empty")]
pub expand: &'a [&'a str],
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata: Option<Metadata>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method: Option<PaymentMethodId>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method_options: Option<UpdateSetupIntentPaymentMethodOptions>,
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_method_types: Option<Vec<String>>,
}
impl<'a> UpdateSetupIntent<'a> {
pub fn new() -> Self {
UpdateSetupIntent {
customer: Default::default(),
description: Default::default(),
expand: Default::default(),
metadata: Default::default(),
payment_method: Default::default(),
payment_method_options: Default::default(),
payment_method_types: Default::default(),
}
}
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct CreateSetupIntentMandateData {
pub customer_acceptance: CreateSetupIntentMandateDataCustomerAcceptance,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct CreateSetupIntentPaymentMethodOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub card: Option<CreateSetupIntentPaymentMethodOptionsCard>,
#[serde(skip_serializing_if = "Option::is_none")]
pub sepa_debit: Option<CreateSetupIntentPaymentMethodOptionsSepaDebit>,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct CreateSetupIntentSingleUse {
pub amount: i64,
pub currency: Currency,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct UpdateSetupIntentPaymentMethodOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub card: Option<UpdateSetupIntentPaymentMethodOptionsCard>,
#[serde(skip_serializing_if = "Option::is_none")]
pub sepa_debit: Option<UpdateSetupIntentPaymentMethodOptionsSepaDebit>,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct CreateSetupIntentMandateDataCustomerAcceptance {
#[serde(skip_serializing_if = "Option::is_none")]
pub accepted_at: Option<Timestamp>,
#[serde(skip_serializing_if = "Option::is_none")]
pub offline: Option<CreateSetupIntentMandateDataCustomerAcceptanceOffline>,
#[serde(skip_serializing_if = "Option::is_none")]
pub online: Option<CreateSetupIntentMandateDataCustomerAcceptanceOnline>,
#[serde(rename = "type")]
pub type_: CreateSetupIntentMandateDataCustomerAcceptanceType,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct CreateSetupIntentPaymentMethodOptionsCard {
#[serde(skip_serializing_if = "Option::is_none")]
pub request_three_d_secure:
Option<CreateSetupIntentPaymentMethodOptionsCardRequestThreeDSecure>,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct CreateSetupIntentPaymentMethodOptionsSepaDebit {
#[serde(skip_serializing_if = "Option::is_none")]
pub mandate_options: Option<CreateSetupIntentPaymentMethodOptionsSepaDebitMandateOptions>,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct UpdateSetupIntentPaymentMethodOptionsCard {
#[serde(skip_serializing_if = "Option::is_none")]
pub request_three_d_secure:
Option<UpdateSetupIntentPaymentMethodOptionsCardRequestThreeDSecure>,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct UpdateSetupIntentPaymentMethodOptionsSepaDebit {
#[serde(skip_serializing_if = "Option::is_none")]
pub mandate_options: Option<UpdateSetupIntentPaymentMethodOptionsSepaDebitMandateOptions>,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct CreateSetupIntentMandateDataCustomerAcceptanceOffline {}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct CreateSetupIntentMandateDataCustomerAcceptanceOnline {
pub ip_address: String,
pub user_agent: String,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct CreateSetupIntentPaymentMethodOptionsSepaDebitMandateOptions {}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct UpdateSetupIntentPaymentMethodOptionsSepaDebitMandateOptions {}
#[derive(Copy, Clone, Debug, Deserialize, Serialize, Eq, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum CreateSetupIntentMandateDataCustomerAcceptanceType {
Offline,
Online,
}
impl CreateSetupIntentMandateDataCustomerAcceptanceType {
pub fn as_str(self) -> &'static str {
match self {
CreateSetupIntentMandateDataCustomerAcceptanceType::Offline => "offline",
CreateSetupIntentMandateDataCustomerAcceptanceType::Online => "online",
}
}
}
impl AsRef<str> for CreateSetupIntentMandateDataCustomerAcceptanceType {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateSetupIntentMandateDataCustomerAcceptanceType {
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 CreateSetupIntentPaymentMethodOptionsCardRequestThreeDSecure {
Any,
Automatic,
}
impl CreateSetupIntentPaymentMethodOptionsCardRequestThreeDSecure {
pub fn as_str(self) -> &'static str {
match self {
CreateSetupIntentPaymentMethodOptionsCardRequestThreeDSecure::Any => "any",
CreateSetupIntentPaymentMethodOptionsCardRequestThreeDSecure::Automatic => "automatic",
}
}
}
impl AsRef<str> for CreateSetupIntentPaymentMethodOptionsCardRequestThreeDSecure {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for CreateSetupIntentPaymentMethodOptionsCardRequestThreeDSecure {
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 SetupIntentCancellationReason {
Abandoned,
Duplicate,
RequestedByCustomer,
}
impl SetupIntentCancellationReason {
pub fn as_str(self) -> &'static str {
match self {
SetupIntentCancellationReason::Abandoned => "abandoned",
SetupIntentCancellationReason::Duplicate => "duplicate",
SetupIntentCancellationReason::RequestedByCustomer => "requested_by_customer",
}
}
}
impl AsRef<str> for SetupIntentCancellationReason {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for SetupIntentCancellationReason {
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 SetupIntentPaymentMethodOptionsCardRequestThreeDSecure {
Any,
Automatic,
ChallengeOnly,
}
impl SetupIntentPaymentMethodOptionsCardRequestThreeDSecure {
pub fn as_str(self) -> &'static str {
match self {
SetupIntentPaymentMethodOptionsCardRequestThreeDSecure::Any => "any",
SetupIntentPaymentMethodOptionsCardRequestThreeDSecure::Automatic => "automatic",
SetupIntentPaymentMethodOptionsCardRequestThreeDSecure::ChallengeOnly => {
"challenge_only"
}
}
}
}
impl AsRef<str> for SetupIntentPaymentMethodOptionsCardRequestThreeDSecure {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for SetupIntentPaymentMethodOptionsCardRequestThreeDSecure {
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 SetupIntentStatus {
Canceled,
Processing,
RequiresAction,
RequiresConfirmation,
RequiresPaymentMethod,
Succeeded,
}
impl SetupIntentStatus {
pub fn as_str(self) -> &'static str {
match self {
SetupIntentStatus::Canceled => "canceled",
SetupIntentStatus::Processing => "processing",
SetupIntentStatus::RequiresAction => "requires_action",
SetupIntentStatus::RequiresConfirmation => "requires_confirmation",
SetupIntentStatus::RequiresPaymentMethod => "requires_payment_method",
SetupIntentStatus::Succeeded => "succeeded",
}
}
}
impl AsRef<str> for SetupIntentStatus {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for SetupIntentStatus {
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 UpdateSetupIntentPaymentMethodOptionsCardRequestThreeDSecure {
Any,
Automatic,
}
impl UpdateSetupIntentPaymentMethodOptionsCardRequestThreeDSecure {
pub fn as_str(self) -> &'static str {
match self {
UpdateSetupIntentPaymentMethodOptionsCardRequestThreeDSecure::Any => "any",
UpdateSetupIntentPaymentMethodOptionsCardRequestThreeDSecure::Automatic => "automatic",
}
}
}
impl AsRef<str> for UpdateSetupIntentPaymentMethodOptionsCardRequestThreeDSecure {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl std::fmt::Display for UpdateSetupIntentPaymentMethodOptionsCardRequestThreeDSecure {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
self.as_str().fmt(f)
}
}