sumup 0.6.0

// The contents of this file are generated; do not modify them.

//! The Payouts model will allow you to track funds you’ve received from SumUp.
//!
//! You can receive a detailed payouts list with information like dates, fees, references and statuses, using the `List payouts` endpoint.
use super::common::*;
/// A single payout-related record.
///
/// A record can represent either:
/// - an actual payout sent to the merchant (`type = PAYOUT`)
/// - a deduction applied against merchant funds for a refund, chargeback, direct debit return, or balance adjustment
#[derive(
    Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize, typed_builder::TypedBuilder,
)]
#[builder(doc)]
pub struct FinancialPayout {
    /// Amount of the payout or deduction in major units.
    ///
    /// Example: `132.45`
    #[builder(setter(doc = "Sets [`amount`](FinancialPayout::amount)."))]
    pub amount: f32,
    /// Three-letter ISO 4217 currency code of the payout.
    ///
    /// Example: `EUR`
    #[builder(setter(into, doc = "Sets [`currency`](FinancialPayout::currency)."))]
    pub currency: String,
    /// Payout date associated with the record, in `YYYY-MM-DD` format.
    ///
    /// Example: `2024-02-29`
    #[builder(setter(doc = "Sets [`date`](FinancialPayout::date)."))]
    pub date: crate::datetime::Date,
    /// Fee amount associated with the payout record, in major units.
    ///
    /// Example: `3.12`
    #[builder(setter(doc = "Sets [`fee`](FinancialPayout::fee)."))]
    pub fee: f32,
    /// Unique identifier of the payout-related record.
    ///
    /// Example: `123456789`
    #[builder(setter(doc = "Sets [`id`](FinancialPayout::id)."))]
    pub id: i64,
    /// Processor or payout reference associated with the record.
    ///
    /// Example: `payout-2024-02-29`
    #[builder(setter(into, doc = "Sets [`reference`](FinancialPayout::reference)."))]
    pub reference: String,
    /// Merchant-facing outcome of the payout record.
    ///
    /// Example: `SUCCESSFUL`
    #[builder(setter(doc = "Sets [`status`](FinancialPayout::status)."))]
    pub status: FinancialPayoutStatus,
    /// Transaction code of the original sale associated with the payout or deduction.
    ///
    /// Example: `TEENSK4W2K`
    #[builder(setter(
        into,
        doc = "Sets [`transaction_code`](FinancialPayout::transaction_code)."
    ))]
    pub transaction_code: String,
    /// High-level payout record category.
    ///
    /// Example: `PAYOUT`
    #[serde(rename = "type")]
    #[builder(setter(doc = "Sets [`r#type`](FinancialPayout::r#type)."))]
    pub r#type: FinancialPayoutType,
}
/// Ordered list of payout and payout-deduction records.
pub type FinancialPayouts = Vec<FinancialPayout>;
/// Merchant-facing outcome of the payout record.
///
/// Example: `SUCCESSFUL`
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub enum FinancialPayoutStatus {
    #[serde(rename = "SUCCESSFUL")]
    Successful,
    #[serde(rename = "FAILED")]
    Failed,
    #[serde(untagged)]
    Other(String),
}
/// High-level payout record category.
///
/// Example: `PAYOUT`
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub enum FinancialPayoutType {
    #[serde(rename = "PAYOUT")]
    Payout,
    #[serde(rename = "CHARGE_BACK_DEDUCTION")]
    ChargeBackDeduction,
    #[serde(rename = "REFUND_DEDUCTION")]
    RefundDeduction,
    #[serde(rename = "DD_RETURN_DEDUCTION")]
    DdReturnDeduction,
    #[serde(rename = "BALANCE_DEDUCTION")]
    BalanceDeduction,
    #[serde(untagged)]
    Other(String),
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub enum ListParamsFormat {
    #[serde(rename = "json")]
    Json,
    #[serde(rename = "csv")]
    Csv,
    #[serde(untagged)]
    Other(String),
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub enum ListParamsOrder {
    #[serde(rename = "asc")]
    Asc,
    #[serde(rename = "desc")]
    Desc,
    #[serde(untagged)]
    Other(String),
}
#[derive(
    Debug,
    Clone,
    Default,
    PartialEq,
    serde::Serialize,
    serde::Deserialize,
    typed_builder::TypedBuilder,
)]
#[builder(doc)]
pub struct ListParams {
    /// Start date of the payout period filter, inclusive, in [ISO8601](https://en.wikipedia.org/wiki/ISO_8601) `date` format (`YYYY-MM-DD`).
    ///
    /// Example: `2024-02-01`
    #[builder(setter(doc = "Sets [`start_date`](ListParams::start_date)."))]
    pub start_date: crate::datetime::Date,
    /// End date of the payout period filter, inclusive, in [ISO8601](https://en.wikipedia.org/wiki/ISO_8601) `date` format (`YYYY-MM-DD`). Must be greater than or equal to `start_date`.
    ///
    /// Example: `2024-02-29`
    #[builder(setter(doc = "Sets [`end_date`](ListParams::end_date)."))]
    pub end_date: crate::datetime::Date,
    /// Response format for the payout list.
    ///
    /// Example: `json`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(
        default,
        setter(strip_option, doc = "Sets [`format`](ListParams::format).")
    )]
    pub format: Option<ListParamsFormat>,
    /// Maximum number of payout records to return.
    ///
    /// Constraints:
    /// - value >= 1
    /// - value <= 9999
    ///
    /// Example: `10`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(
        default,
        setter(strip_option, doc = "Sets [`limit`](ListParams::limit).")
    )]
    pub limit: Option<i64>,
    /// Sort direction for the returned payouts.
    ///
    /// Example: `desc`
    #[serde(skip_serializing_if = "Option::is_none")]
    #[builder(
        default,
        setter(strip_option, doc = "Sets [`order`](ListParams::order).")
    )]
    pub order: Option<ListParamsOrder>,
}
use crate::client::Client;
#[derive(Debug, PartialEq)]
pub enum ListErrorBody {
    BadRequest(crate::error::UnknownApiBody),
    Unauthorized(Problem),
}
impl crate::error::ProblemDetails for ListErrorBody {
    fn problem(&self) -> Option<&crate::resources::common::Problem> {
        match self {
            Self::BadRequest(body) => crate::error::ProblemDetails::problem(body),
            Self::Unauthorized(problem) => Some(problem),
        }
    }
}
/// Client for the Payouts API endpoints.
#[derive(Debug)]
pub struct PayoutsClient<'a> {
    client: &'a Client,
}
impl<'a> PayoutsClient<'a> {
    pub(crate) fn new(client: &'a Client) -> Self {
        Self { client }
    }
    /// Returns a reference to the underlying client.
    pub fn client(&self) -> &Client {
        self.client
    }
    /// List payouts
    ///
    /// Lists payout and payout-deduction records for the specified merchant account within the requested date range.
    ///
    /// The response can include:
    /// - regular payouts (`type = PAYOUT`)
    /// - deduction records for refunds, chargebacks, direct debit returns, or balance adjustments
    ///
    /// Results are sorted by payout date in the requested `order`.
    ///
    /// Responses:
    /// - 200: Returns the list of payout and deduction records for the requested period.
    /// - 400: The request is invalid for the submitted query parameters.
    /// - 401: The request is not authorized.
    pub async fn list(
        &self,
        merchant_code: impl AsRef<str>,
        params: ListParams,
    ) -> crate::error::SdkResult<FinancialPayouts, ListErrorBody> {
        let path = format!("/v1.0/merchants/{}/payouts", merchant_code.as_ref());
        let url = format!("{}{}", self.client.base_url(), path);
        let mut request = self
            .client
            .http_client()
            .get(&url)
            .header("User-Agent", crate::version::user_agent())
            .timeout(self.client.timeout());
        if let Some(authorization) = self.client.authorization() {
            request = request.header("Authorization", format!("Bearer {}", authorization));
        }
        for (header_name, header_value) in self.client.runtime_headers() {
            request = request.header(*header_name, header_value);
        }
        request = request.query(&[("start_date", &params.start_date)]);
        request = request.query(&[("end_date", &params.end_date)]);
        if let Some(ref value) = params.format {
            request = request.query(&[("format", value)]);
        }
        if let Some(ref value) = params.limit {
            request = request.query(&[("limit", value)]);
        }
        if let Some(ref value) = params.order {
            request = request.query(&[("order", value)]);
        }
        let response = request.send().await?;
        let status = response.status();
        match status {
            reqwest::StatusCode::OK => {
                let data: FinancialPayouts = response.json().await?;
                Ok(data)
            }
            reqwest::StatusCode::BAD_REQUEST => {
                Err(crate::error::SdkError::from_response(response, |raw| {
                    Ok(ListErrorBody::BadRequest(
                        crate::error::UnknownApiBody::from_bytes(raw),
                    ))
                })
                .await)
            }
            reqwest::StatusCode::UNAUTHORIZED => {
                Err(crate::error::SdkError::from_response(response, |raw| {
                    serde_json::from_slice::<Problem>(raw).map(ListErrorBody::Unauthorized)
                })
                .await)
            }
            _ => Err(crate::error::SdkError::unexpected_response(response).await),
        }
    }
}