async-stripe-misc 1.0.0-rc.8

use stripe_client_core::{
    RequestBuilder, StripeBlockingClient, StripeClient, StripeMethod, StripeRequest,
};

#[derive(Clone, Eq, PartialEq)]
#[cfg_attr(not(feature = "redact-generated-debug"), derive(Debug))]
#[derive(serde::Serialize)]
struct RetrieveFinancialConnectionsSessionBuilder {
    #[serde(skip_serializing_if = "Option::is_none")]
    expand: Option<Vec<String>>,
}
#[cfg(feature = "redact-generated-debug")]
impl std::fmt::Debug for RetrieveFinancialConnectionsSessionBuilder {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("RetrieveFinancialConnectionsSessionBuilder").finish_non_exhaustive()
    }
}
impl RetrieveFinancialConnectionsSessionBuilder {
    fn new() -> Self {
        Self { expand: None }
    }
}
/// Retrieves the details of a Financial Connections `Session`
#[derive(Clone)]
#[cfg_attr(not(feature = "redact-generated-debug"), derive(Debug))]
#[derive(serde::Serialize)]
pub struct RetrieveFinancialConnectionsSession {
    inner: RetrieveFinancialConnectionsSessionBuilder,
    session: stripe_misc::FinancialConnectionsSessionId,
}
#[cfg(feature = "redact-generated-debug")]
impl std::fmt::Debug for RetrieveFinancialConnectionsSession {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("RetrieveFinancialConnectionsSession").finish_non_exhaustive()
    }
}
impl RetrieveFinancialConnectionsSession {
    /// Construct a new `RetrieveFinancialConnectionsSession`.
    pub fn new(session: impl Into<stripe_misc::FinancialConnectionsSessionId>) -> Self {
        Self { session: session.into(), inner: RetrieveFinancialConnectionsSessionBuilder::new() }
    }
    /// Specifies which fields in the response should be expanded.
    pub fn expand(mut self, expand: impl Into<Vec<String>>) -> Self {
        self.inner.expand = Some(expand.into());
        self
    }
}
impl RetrieveFinancialConnectionsSession {
    /// Send the request and return the deserialized response.
    pub async fn send<C: StripeClient>(
        &self,
        client: &C,
    ) -> Result<<Self as StripeRequest>::Output, C::Err> {
        self.customize().send(client).await
    }

    /// Send the request and return the deserialized response, blocking until completion.
    pub fn send_blocking<C: StripeBlockingClient>(
        &self,
        client: &C,
    ) -> Result<<Self as StripeRequest>::Output, C::Err> {
        self.customize().send_blocking(client)
    }
}

impl StripeRequest for RetrieveFinancialConnectionsSession {
    type Output = stripe_misc::FinancialConnectionsSession;

    fn build(&self) -> RequestBuilder {
        let session = &self.session;
        RequestBuilder::new(StripeMethod::Get, format!("/financial_connections/sessions/{session}"))
            .query(&self.inner)
    }
}
#[derive(Clone, Eq, PartialEq)]
#[cfg_attr(not(feature = "redact-generated-debug"), derive(Debug))]
#[derive(serde::Serialize)]
struct CreateFinancialConnectionsSessionBuilder {
    account_holder: CreateFinancialConnectionsSessionAccountHolder,
    #[serde(skip_serializing_if = "Option::is_none")]
    expand: Option<Vec<String>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    filters: Option<CreateFinancialConnectionsSessionFilters>,
    #[serde(skip_serializing_if = "Option::is_none")]
    limits: Option<CreateFinancialConnectionsSessionLimits>,
    #[serde(skip_serializing_if = "Option::is_none")]
    manual_entry: Option<CreateFinancialConnectionsSessionManualEntry>,
    permissions: Vec<stripe_misc::FinancialConnectionsSessionPermissions>,
    #[serde(skip_serializing_if = "Option::is_none")]
    prefetch: Option<Vec<stripe_misc::FinancialConnectionsSessionPrefetch>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    return_url: Option<String>,
}
#[cfg(feature = "redact-generated-debug")]
impl std::fmt::Debug for CreateFinancialConnectionsSessionBuilder {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("CreateFinancialConnectionsSessionBuilder").finish_non_exhaustive()
    }
}
impl CreateFinancialConnectionsSessionBuilder {
    fn new(
        account_holder: impl Into<CreateFinancialConnectionsSessionAccountHolder>,
        permissions: impl Into<Vec<stripe_misc::FinancialConnectionsSessionPermissions>>,
    ) -> Self {
        Self {
            account_holder: account_holder.into(),
            expand: None,
            filters: None,
            limits: None,
            manual_entry: None,
            permissions: permissions.into(),
            prefetch: None,
            return_url: None,
        }
    }
}
/// The account holder to link accounts for.
#[derive(Clone, Eq, PartialEq)]
#[cfg_attr(not(feature = "redact-generated-debug"), derive(Debug))]
#[derive(serde::Serialize)]
pub struct CreateFinancialConnectionsSessionAccountHolder {
    /// The ID of the Stripe account whose accounts you will retrieve.
    /// Only available when `type` is `account`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
    /// The ID of the Stripe customer whose accounts you will retrieve.
    /// Only available when `type` is `customer`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub customer: Option<String>,
    /// The ID of Account representing a customer whose accounts you will retrieve.
    /// Only available when `type` is `customer`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub customer_account: Option<String>,
    /// Type of account holder to collect accounts for.
    #[serde(rename = "type")]
    pub type_: CreateFinancialConnectionsSessionAccountHolderType,
}
#[cfg(feature = "redact-generated-debug")]
impl std::fmt::Debug for CreateFinancialConnectionsSessionAccountHolder {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("CreateFinancialConnectionsSessionAccountHolder").finish_non_exhaustive()
    }
}
impl CreateFinancialConnectionsSessionAccountHolder {
    pub fn new(type_: impl Into<CreateFinancialConnectionsSessionAccountHolderType>) -> Self {
        Self { account: None, customer: None, customer_account: None, type_: type_.into() }
    }
}
/// Type of account holder to collect accounts for.
#[derive(Clone, Eq, PartialEq)]
#[non_exhaustive]
pub enum CreateFinancialConnectionsSessionAccountHolderType {
    Account,
    Customer,
    /// An unrecognized value from Stripe. Should not be used as a request parameter.
    Unknown(String),
}
impl CreateFinancialConnectionsSessionAccountHolderType {
    pub fn as_str(&self) -> &str {
        use CreateFinancialConnectionsSessionAccountHolderType::*;
        match self {
            Account => "account",
            Customer => "customer",
            Unknown(v) => v,
        }
    }
}

impl std::str::FromStr for CreateFinancialConnectionsSessionAccountHolderType {
    type Err = std::convert::Infallible;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        use CreateFinancialConnectionsSessionAccountHolderType::*;
        match s {
            "account" => Ok(Account),
            "customer" => Ok(Customer),
            v => {
                tracing::warn!(
                    "Unknown value '{}' for enum '{}'",
                    v,
                    "CreateFinancialConnectionsSessionAccountHolderType"
                );
                Ok(Unknown(v.to_owned()))
            }
        }
    }
}
impl std::fmt::Display for CreateFinancialConnectionsSessionAccountHolderType {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

#[cfg(not(feature = "redact-generated-debug"))]
impl std::fmt::Debug for CreateFinancialConnectionsSessionAccountHolderType {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}
#[cfg(feature = "redact-generated-debug")]
impl std::fmt::Debug for CreateFinancialConnectionsSessionAccountHolderType {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct(stringify!(CreateFinancialConnectionsSessionAccountHolderType))
            .finish_non_exhaustive()
    }
}
impl serde::Serialize for CreateFinancialConnectionsSessionAccountHolderType {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(self.as_str())
    }
}
#[cfg(feature = "deserialize")]
impl<'de> serde::Deserialize<'de> for CreateFinancialConnectionsSessionAccountHolderType {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        use std::str::FromStr;
        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
        Ok(Self::from_str(&s).expect("infallible"))
    }
}
/// Filters to restrict the kinds of accounts to collect.
#[derive(Clone, Eq, PartialEq)]
#[cfg_attr(not(feature = "redact-generated-debug"), derive(Debug))]
#[derive(serde::Serialize)]
pub struct CreateFinancialConnectionsSessionFilters {
    /// Restricts the Session to subcategories of accounts that can be linked.
    /// Valid subcategories are: `checking`, `savings`, `mortgage`, `line_of_credit`, `credit_card`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account_subcategories:
        Option<Vec<CreateFinancialConnectionsSessionFiltersAccountSubcategories>>,
    /// List of countries from which to collect accounts.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub countries: Option<Vec<String>>,
    /// Whether the session should require payment method support and successful account number retrieval before completion.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub require_payment_method_support:
        Option<CreateFinancialConnectionsSessionFiltersRequirePaymentMethodSupport>,
}
#[cfg(feature = "redact-generated-debug")]
impl std::fmt::Debug for CreateFinancialConnectionsSessionFilters {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("CreateFinancialConnectionsSessionFilters").finish_non_exhaustive()
    }
}
impl CreateFinancialConnectionsSessionFilters {
    pub fn new() -> Self {
        Self { account_subcategories: None, countries: None, require_payment_method_support: None }
    }
}
impl Default for CreateFinancialConnectionsSessionFilters {
    fn default() -> Self {
        Self::new()
    }
}
/// Restricts the Session to subcategories of accounts that can be linked.
/// Valid subcategories are: `checking`, `savings`, `mortgage`, `line_of_credit`, `credit_card`.
#[derive(Clone, Eq, PartialEq)]
#[non_exhaustive]
pub enum CreateFinancialConnectionsSessionFiltersAccountSubcategories {
    Checking,
    CreditCard,
    LineOfCredit,
    Mortgage,
    Savings,
    /// An unrecognized value from Stripe. Should not be used as a request parameter.
    Unknown(String),
}
impl CreateFinancialConnectionsSessionFiltersAccountSubcategories {
    pub fn as_str(&self) -> &str {
        use CreateFinancialConnectionsSessionFiltersAccountSubcategories::*;
        match self {
            Checking => "checking",
            CreditCard => "credit_card",
            LineOfCredit => "line_of_credit",
            Mortgage => "mortgage",
            Savings => "savings",
            Unknown(v) => v,
        }
    }
}

impl std::str::FromStr for CreateFinancialConnectionsSessionFiltersAccountSubcategories {
    type Err = std::convert::Infallible;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        use CreateFinancialConnectionsSessionFiltersAccountSubcategories::*;
        match s {
            "checking" => Ok(Checking),
            "credit_card" => Ok(CreditCard),
            "line_of_credit" => Ok(LineOfCredit),
            "mortgage" => Ok(Mortgage),
            "savings" => Ok(Savings),
            v => {
                tracing::warn!(
                    "Unknown value '{}' for enum '{}'",
                    v,
                    "CreateFinancialConnectionsSessionFiltersAccountSubcategories"
                );
                Ok(Unknown(v.to_owned()))
            }
        }
    }
}
impl std::fmt::Display for CreateFinancialConnectionsSessionFiltersAccountSubcategories {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

#[cfg(not(feature = "redact-generated-debug"))]
impl std::fmt::Debug for CreateFinancialConnectionsSessionFiltersAccountSubcategories {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}
#[cfg(feature = "redact-generated-debug")]
impl std::fmt::Debug for CreateFinancialConnectionsSessionFiltersAccountSubcategories {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct(stringify!(CreateFinancialConnectionsSessionFiltersAccountSubcategories))
            .finish_non_exhaustive()
    }
}
impl serde::Serialize for CreateFinancialConnectionsSessionFiltersAccountSubcategories {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(self.as_str())
    }
}
#[cfg(feature = "deserialize")]
impl<'de> serde::Deserialize<'de> for CreateFinancialConnectionsSessionFiltersAccountSubcategories {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        use std::str::FromStr;
        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
        Ok(Self::from_str(&s).expect("infallible"))
    }
}
/// Whether the session should require payment method support and successful account number retrieval before completion.
#[derive(Clone, Eq, PartialEq)]
#[non_exhaustive]
pub enum CreateFinancialConnectionsSessionFiltersRequirePaymentMethodSupport {
    All,
    AtLeastOne,
    None,
    /// An unrecognized value from Stripe. Should not be used as a request parameter.
    Unknown(String),
}
impl CreateFinancialConnectionsSessionFiltersRequirePaymentMethodSupport {
    pub fn as_str(&self) -> &str {
        use CreateFinancialConnectionsSessionFiltersRequirePaymentMethodSupport::*;
        match self {
            All => "all",
            AtLeastOne => "at_least_one",
            None => "none",
            Unknown(v) => v,
        }
    }
}

impl std::str::FromStr for CreateFinancialConnectionsSessionFiltersRequirePaymentMethodSupport {
    type Err = std::convert::Infallible;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        use CreateFinancialConnectionsSessionFiltersRequirePaymentMethodSupport::*;
        match s {
            "all" => Ok(All),
            "at_least_one" => Ok(AtLeastOne),
            "none" => Ok(None),
            v => {
                tracing::warn!(
                    "Unknown value '{}' for enum '{}'",
                    v,
                    "CreateFinancialConnectionsSessionFiltersRequirePaymentMethodSupport"
                );
                Ok(Unknown(v.to_owned()))
            }
        }
    }
}
impl std::fmt::Display for CreateFinancialConnectionsSessionFiltersRequirePaymentMethodSupport {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

#[cfg(not(feature = "redact-generated-debug"))]
impl std::fmt::Debug for CreateFinancialConnectionsSessionFiltersRequirePaymentMethodSupport {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}
#[cfg(feature = "redact-generated-debug")]
impl std::fmt::Debug for CreateFinancialConnectionsSessionFiltersRequirePaymentMethodSupport {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct(stringify!(
            CreateFinancialConnectionsSessionFiltersRequirePaymentMethodSupport
        ))
        .finish_non_exhaustive()
    }
}
impl serde::Serialize for CreateFinancialConnectionsSessionFiltersRequirePaymentMethodSupport {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(self.as_str())
    }
}
#[cfg(feature = "deserialize")]
impl<'de> serde::Deserialize<'de>
    for CreateFinancialConnectionsSessionFiltersRequirePaymentMethodSupport
{
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        use std::str::FromStr;
        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
        Ok(Self::from_str(&s).expect("infallible"))
    }
}
/// Settings for configuring Session-specific limits.
#[derive(Copy, Clone, Eq, PartialEq)]
#[cfg_attr(not(feature = "redact-generated-debug"), derive(Debug))]
#[derive(serde::Serialize)]
pub struct CreateFinancialConnectionsSessionLimits {
    /// The number of accounts that can be linked in this Session.
    /// Pass an empty value to allow any number of accounts.
    pub accounts: i64,
}
#[cfg(feature = "redact-generated-debug")]
impl std::fmt::Debug for CreateFinancialConnectionsSessionLimits {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("CreateFinancialConnectionsSessionLimits").finish_non_exhaustive()
    }
}
impl CreateFinancialConnectionsSessionLimits {
    pub fn new(accounts: impl Into<i64>) -> Self {
        Self { accounts: accounts.into() }
    }
}
/// Customize manual entry behavior
#[derive(Clone, Eq, PartialEq)]
#[cfg_attr(not(feature = "redact-generated-debug"), derive(Debug))]
#[derive(serde::Serialize)]
pub struct CreateFinancialConnectionsSessionManualEntry {
    /// How manual entry should be handled.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mode: Option<CreateFinancialConnectionsSessionManualEntryMode>,
}
#[cfg(feature = "redact-generated-debug")]
impl std::fmt::Debug for CreateFinancialConnectionsSessionManualEntry {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("CreateFinancialConnectionsSessionManualEntry").finish_non_exhaustive()
    }
}
impl CreateFinancialConnectionsSessionManualEntry {
    pub fn new() -> Self {
        Self { mode: None }
    }
}
impl Default for CreateFinancialConnectionsSessionManualEntry {
    fn default() -> Self {
        Self::new()
    }
}
/// How manual entry should be handled.
#[derive(Clone, Eq, PartialEq)]
#[non_exhaustive]
pub enum CreateFinancialConnectionsSessionManualEntryMode {
    Automatic,
    Disabled,
    /// An unrecognized value from Stripe. Should not be used as a request parameter.
    Unknown(String),
}
impl CreateFinancialConnectionsSessionManualEntryMode {
    pub fn as_str(&self) -> &str {
        use CreateFinancialConnectionsSessionManualEntryMode::*;
        match self {
            Automatic => "automatic",
            Disabled => "disabled",
            Unknown(v) => v,
        }
    }
}

impl std::str::FromStr for CreateFinancialConnectionsSessionManualEntryMode {
    type Err = std::convert::Infallible;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        use CreateFinancialConnectionsSessionManualEntryMode::*;
        match s {
            "automatic" => Ok(Automatic),
            "disabled" => Ok(Disabled),
            v => {
                tracing::warn!(
                    "Unknown value '{}' for enum '{}'",
                    v,
                    "CreateFinancialConnectionsSessionManualEntryMode"
                );
                Ok(Unknown(v.to_owned()))
            }
        }
    }
}
impl std::fmt::Display for CreateFinancialConnectionsSessionManualEntryMode {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

#[cfg(not(feature = "redact-generated-debug"))]
impl std::fmt::Debug for CreateFinancialConnectionsSessionManualEntryMode {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}
#[cfg(feature = "redact-generated-debug")]
impl std::fmt::Debug for CreateFinancialConnectionsSessionManualEntryMode {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct(stringify!(CreateFinancialConnectionsSessionManualEntryMode))
            .finish_non_exhaustive()
    }
}
impl serde::Serialize for CreateFinancialConnectionsSessionManualEntryMode {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_str(self.as_str())
    }
}
#[cfg(feature = "deserialize")]
impl<'de> serde::Deserialize<'de> for CreateFinancialConnectionsSessionManualEntryMode {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        use std::str::FromStr;
        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
        Ok(Self::from_str(&s).expect("infallible"))
    }
}
/// To launch the Financial Connections authorization flow, create a `Session`.
/// The session’s `client_secret` can be used to launch the flow using Stripe.js.
#[derive(Clone)]
#[cfg_attr(not(feature = "redact-generated-debug"), derive(Debug))]
#[derive(serde::Serialize)]
pub struct CreateFinancialConnectionsSession {
    inner: CreateFinancialConnectionsSessionBuilder,
}
#[cfg(feature = "redact-generated-debug")]
impl std::fmt::Debug for CreateFinancialConnectionsSession {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("CreateFinancialConnectionsSession").finish_non_exhaustive()
    }
}
impl CreateFinancialConnectionsSession {
    /// Construct a new `CreateFinancialConnectionsSession`.
    pub fn new(
        account_holder: impl Into<CreateFinancialConnectionsSessionAccountHolder>,
        permissions: impl Into<Vec<stripe_misc::FinancialConnectionsSessionPermissions>>,
    ) -> Self {
        Self {
            inner: CreateFinancialConnectionsSessionBuilder::new(
                account_holder.into(),
                permissions.into(),
            ),
        }
    }
    /// Specifies which fields in the response should be expanded.
    pub fn expand(mut self, expand: impl Into<Vec<String>>) -> Self {
        self.inner.expand = Some(expand.into());
        self
    }
    /// Filters to restrict the kinds of accounts to collect.
    pub fn filters(mut self, filters: impl Into<CreateFinancialConnectionsSessionFilters>) -> Self {
        self.inner.filters = Some(filters.into());
        self
    }
    /// Settings for configuring Session-specific limits.
    pub fn limits(mut self, limits: impl Into<CreateFinancialConnectionsSessionLimits>) -> Self {
        self.inner.limits = Some(limits.into());
        self
    }
    /// Customize manual entry behavior
    pub fn manual_entry(
        mut self,
        manual_entry: impl Into<CreateFinancialConnectionsSessionManualEntry>,
    ) -> Self {
        self.inner.manual_entry = Some(manual_entry.into());
        self
    }
    /// List of data features that you would like to retrieve upon account creation.
    pub fn prefetch(
        mut self,
        prefetch: impl Into<Vec<stripe_misc::FinancialConnectionsSessionPrefetch>>,
    ) -> Self {
        self.inner.prefetch = Some(prefetch.into());
        self
    }
    /// For webview integrations only.
    /// Upon completing OAuth login in the native browser, the user will be redirected to this URL to return to your app.
    pub fn return_url(mut self, return_url: impl Into<String>) -> Self {
        self.inner.return_url = Some(return_url.into());
        self
    }
}
impl CreateFinancialConnectionsSession {
    /// Send the request and return the deserialized response.
    pub async fn send<C: StripeClient>(
        &self,
        client: &C,
    ) -> Result<<Self as StripeRequest>::Output, C::Err> {
        self.customize().send(client).await
    }

    /// Send the request and return the deserialized response, blocking until completion.
    pub fn send_blocking<C: StripeBlockingClient>(
        &self,
        client: &C,
    ) -> Result<<Self as StripeRequest>::Output, C::Err> {
        self.customize().send_blocking(client)
    }
}

impl StripeRequest for CreateFinancialConnectionsSession {
    type Output = stripe_misc::FinancialConnectionsSession;

    fn build(&self) -> RequestBuilder {
        RequestBuilder::new(StripeMethod::Post, "/financial_connections/sessions").form(&self.inner)
    }
}