efi-bank 0.1.21

use serde::{Deserialize, Serialize};
use serde_repr::{Deserialize_repr, Serialize_repr};
use serde_with::skip_serializing_none;

// ========== Split de pagamento Pix ==========

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SplitRepasse {
    pub tipo: String,
    pub valor: String,
    pub favorecido: SplitFavorecido,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SplitFavorecido {
    pub cpf: String,
    pub conta: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SplitParte {
    pub tipo: String,
    pub valor: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SplitPayload {
    pub descricao: String,
    pub lancamento: SplitLancamento,
    pub split: SplitConfig,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SplitLancamento {
    pub imediato: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SplitConfig {
    pub divisao_tarifa: String,
    pub minha_parte: SplitParte,
    pub repasses: Vec<SplitRepasse>,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SplitConfigResponse {
    pub id: String,
    pub descricao: Option<String>,
    pub lancamento: Option<SplitLancamento>,
    pub split: Option<SplitConfig>,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SplitLinkResponse {
    pub status: String,
    pub message: Option<String>,
}

// ========== COB - Immediate Charge (Cobrança Imediata) ==========

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CobPayload {
    pub calendario: CobCalendario,
    pub devedor: Option<CobPessoa>,
    pub valor: CobValor,
    pub chave: String,
    pub solicitacao_pagador: Option<String>,
    pub info_adicionais: Option<Vec<CobInfoAdicional>>,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CobCalendario {
    pub data_de_vencimento: Option<String>,
    pub validade_apos_vencimento: Option<i32>,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CobPessoa {
    pub cpf: Option<String>,
    pub cnpj: Option<String>,
    pub nome: Option<String>,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CobValor {
    pub original: String,
    pub multa: Option<String>,
    pub juros: Option<String>,
    pub desconto: Option<String>,
    pub abatimento: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CobInfoAdicional {
    pub nome: String,
    pub valor: String,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CobResponse {
    pub txid: String,
    pub calendario: Option<CobCalendarioResponse>,
    pub devedor: Option<CobPessoa>,
    pub valor: Option<CobValor>,
    pub chave: Option<String>,
    pub solicitacao_pagador: Option<String>,
    pub info_adicionais: Option<Vec<CobInfoAdicional>>,
    pub br: Option<String>,
    pub status: Option<String>,
    pub criacao_date_time: Option<String>,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CobCalendarioResponse {
    pub criacao_date_time: Option<String>,
    pub data_de_vencimento: Option<String>,
    pub validade_apos_vencimento: Option<i32>,
}

// ========== COBV - Expiring Charge (Cobrança com Vencimento) ==========

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CobvPayload {
    pub calendario: CobvCalendario,
    pub devedor: Option<CobPessoa>,
    pub valor: CobValor,
    pub chave: String,
    pub solicitacao_pagador: Option<String>,
    pub info_adicionais: Option<Vec<CobInfoAdicional>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CobvCalendario {
    pub data_de_vencimento: String,
    pub validade_apos_vencimento: i32,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CobvResponse {
    pub txid: String,
    pub calendario: Option<CobvCalendarioResponse>,
    pub devedor: Option<CobPessoa>,
    pub valor: Option<CobValor>,
    pub chave: Option<String>,
    pub solicitacao_pagador: Option<String>,
    pub info_adicionais: Option<Vec<CobInfoAdicional>>,
    pub br: Option<String>,
    pub status: Option<String>,
    pub criacao_date_time: Option<String>,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CobvCalendarioResponse {
    pub criacao_date_time: Option<String>,
    pub data_de_vencimento: Option<String>,
    pub validade_apos_vencimento: Option<i32>,
}

// ========== Webhook Management ==========

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WebhookPayload {
    pub url: String,
    pub chave: String,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct WebhookResponse {
    pub id: String,
    pub url: String,
    pub chave: Option<String>,
    pub criacao_date_time: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WebhooksListResponse {
    pub webhooks: Vec<WebhookResponse>,
}

// ========== PIX Transactions ==========

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PixTransactionPayload {
    pub valor: String,
    pub chave_destino: String,
    pub descricao: Option<String>,
    pub idempotency_key: Option<String>,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PixTransactionResponse {
    pub id: String,
    pub end_to_end_id: String,
    pub valor: String,
    pub status: String,
    pub chave_destino: Option<String>,
    pub data_hora: Option<String>,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PixTransactionDetailResponse {
    pub id: String,
    pub end_to_end_id: String,
    pub valor: String,
    pub status: String,
    pub chave_destino: Option<String>,
    pub chave_origem: Option<String>,
    pub data_hora: Option<String>,
    pub motivo_cancelamento: Option<String>,
}

// ========== Billing API - Split de Pagamento ==========

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BillingRepasse {
    pub payee_code: String,
    /// transfer percentage, where 9000 equals 90%
    pub percentage: Option<i32>,
    pub fixed: Option<i32>,
}

#[derive(Debug, Clone, Serialize_repr, Deserialize_repr)]
#[repr(u8)]
pub enum BillingRepasseType {
    /// fee is deducted only from the account that issued the charge
    IssuerOnly = 1,
    /// fee is deducted proportionally according to the percentage defined for each account receiving the transfer
    Proportional = 2,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BillingMarketplace {
    pub repasses: Vec<BillingRepasse>,
    pub mode: BillingRepasseType,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BillingMarketplaceResponse {
    pub repasses: Vec<BillingRepasse>,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BillingItem {
    pub name: String,
    pub value: i64,
    pub amount: i32,
    pub marketplace: Option<BillingMarketplace>,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BillingItemResponse {
    pub name: String,
    pub value: i64,
    pub amount: i32,
    pub marketplace: Option<BillingMarketplaceResponse>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BillingShipping {
    pub name: String,
    pub value: i64,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BillingAddress {
    pub street: Option<String>,
    pub number: Option<String>,
    pub neighborhood: Option<String>,
    pub zipcode: Option<String>,
    pub city: Option<String>,
    pub complement: Option<String>,
    pub state: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BillingJuridicalPerson {
    pub corporate_name: String,
    pub cnpj: String,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BillingCustomer {
    pub name: Option<String>,
    pub cpf: Option<String>,
    pub email: Option<String>,
    pub birth: Option<String>,
    pub phone_number: Option<String>,
    pub address: Option<BillingAddress>,
    pub juridical_person: Option<BillingJuridicalPerson>,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BillingBilletConfigurations {
    pub fine: Option<i64>,
    pub interest: Option<i64>,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BillingBankingBillet {
    pub expire_at: Option<String>,
    pub customer: BillingCustomer,
    pub configurations: Option<BillingBilletConfigurations>,
    pub message: Option<String>,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BillingPayment {
    pub banking_billet: Option<BillingBankingBillet>,
    pub credit_card: Option<BillingCreditCard>,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BillingCreditCard {
    pub customer: BillingCustomer,
    pub installments: i32,
    pub payment_token: String,
    pub billing_address: Option<BillingAddress>,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BillingChargeMetadata {
    /// Your valid URL address that will receive notifications of transaction status changes.
    /// Maximum of 255 characters.
    pub notification_url: Option<String>,
    /// Allows associating an Efí transaction with a specific ID from your system or application,
    /// allowing you to identify it if you have a specific identification and want to maintain it.
    /// Maximum of 255 characters.
    pub custom_id: Option<String>,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BillingChargeCreateRequest {
    pub items: Vec<BillingItem>,
    pub metadata: Option<BillingChargeMetadata>,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BillingChargeOneStepRequest {
    pub items: Vec<BillingItem>,
    pub shippings: Option<Vec<BillingShipping>>,
    pub payment: BillingPayment,
    pub metadata: Option<BillingChargeMetadata>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BillingChargePayRequest {
    pub payment: BillingPayment,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BillingChargeResponse {
    pub code: i32,
    pub data: BillingChargeData,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BillingChargeDetailResponse {
    pub code: i32,
    pub data: BillingChargeDetailData,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BillingChargeDetailData {
    pub charge_id: i64,
    pub total: i64,
    pub status: String,
    pub custom_id: Option<String>,
    pub created_at: String,
    pub notification_url: Option<String>,
    pub items: Vec<BillingItemResponse>,
    pub history: Vec<BillingChargeHistoryEntry>,
    pub shippings: Option<Vec<BillingChargeShipping>>,
    pub customer: Option<BillingCustomer>,
    pub payment: BillingChargeDetailPayment,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BillingChargeHistoryEntry {
    pub message: String,
    pub created_at: String,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BillingChargeShipping {
    pub name: String,
    pub value: i64,
    pub payee_code: Option<String>,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BillingChargeDetailPayment {
    pub method: String,
    pub created_at: String,
    pub message: Option<String>,
    pub banking_billet: BillingChargeDetailBankingBillet,
    pub credit_card: Option<serde_json::Value>,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BillingChargeDetailBankingBillet {
    pub barcode: String,
    pub pix: BillingPix,
    pub link: String,
    pub billet_link: String,
    pub pdf: BillingPdf,
    pub expire_at: String,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BillingChargeData {
    pub barcode: String,
    #[serde(rename = "pix")]
    pub pix: Option<BillingPix>,
    pub link: String,
    pub billet_link: String,
    pub pdf: BillingPdf,
    pub expire_at: String,
    pub charge_id: i64,
    pub status: String,
    pub total: i64,
    pub payment: String,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BillingPix {
    pub qrcode: String,
    pub qrcode_image: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BillingPdf {
    pub charge: String,
}

// ========== Billing API - Carnet ===========

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CarnetCustomer {
    pub name: Option<String>,
    pub cpf: Option<String>,
    pub cnpj: Option<String>,
    pub email: Option<String>,
    pub phone_number: Option<String>,
    pub birth: Option<String>,
    pub juridical_person: Option<BillingJuridicalPerson>,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CarnetCreateRequest {
    pub items: Vec<BillingItem>,
    pub customer: CarnetCustomer,
    pub expire_at: String,
    pub message: Option<String>,
    pub repeats: i32,
    pub split_items: Option<bool>,
    pub metadata: Option<CarnetMetadataRequest>,
    pub configurations: Option<BillingBilletConfigurations>,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CarnetMetadataRequest {
    pub notification_url: Option<String>,
    pub custom_id: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CarnetParcelRequest {
    pub expire_at: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CarnetParcelsRequest {
    pub parcels: Vec<CarnetParcel>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CarnetParcel {
    pub parcel: i32,
    pub expire_at: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CarnetHistoryRequest {
    pub description: String,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CarnetData {
    pub carnet_id: i64,
    pub status: String,
    pub cover: String,
    pub link: String,
    pub carnet_link: String,
    pub pdf: CarnetPdf,
    pub charges: Vec<CarnetCharge>,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CarnetPdf {
    pub carnet: String,
    pub cover: String,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CarnetCharge {
    pub charge_id: i64,
    pub parcel: String,
    pub status: String,
    pub value: i64,
    pub expire_at: String,
    pub url: String,
    pub parcel_link: String,
    pub pdf: CarnetChargePdf,
    pub barcode: String,
    pub pix: BillingPix,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CarnetChargePdf {
    pub charge: String,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CarnetResponse {
    pub code: i32,
    pub data: CarnetData,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BillingNotificationResponse {
    pub code: i32,
    pub data: Vec<BillingNotificationData>,
}

#[skip_serializing_none]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BillingNotificationData {
    pub created_at: String,
    pub custom_id: Option<String>,
    pub id: i64,
    pub identifiers: BillingNotificationIdentifiers,
    pub status: BillingNotificationStatus,
    #[serde(rename = "type")]
    pub r#type: String,
    pub received_by_bank_at: Option<String>,
    pub value: Option<i64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BillingNotificationIdentifiers {
    pub charge_id: i64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BillingNotificationStatus {
    pub current: String,
    pub previous: Option<String>,
}