reevit 0.2.0

use std::collections::HashMap;

use serde::{Deserialize, Serialize};
use serde_json::Value;

/// Arbitrary structured metadata attached to a Reevit resource.
pub type Metadata = HashMap<String, Value>;

/// Routing preferences supplied while creating a payment intent.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
pub struct FraudPolicyInput {
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub prefer: Vec<String>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub allowed_providers: Vec<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_amount: Option<i64>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub blocked_bins: Vec<String>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub allowed_bins: Vec<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub velocity_max_per_minute: Option<u32>,
}

/// Input used to create a payment intent or checkout session.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct PaymentIntentRequest {
    pub amount: i64,
    pub currency: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub method: Option<String>,
    pub country: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reference: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub customer_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub policy: Option<FraudPolicyInput>,
    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
    pub metadata: Metadata,
}

/// A payment intent returned immediately after creation.
#[derive(Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct PaymentIntent {
    pub id: String,
    pub org_id: Option<String>,
    pub connection_id: String,
    pub provider: String,
    pub provider_ref_id: Option<String>,
    pub status: String,
    pub client_secret: Option<String>,
    pub session_secret: Option<String>,
    pub psp_public_key: Option<String>,
    #[serde(default)]
    pub psp_credentials: Metadata,
    pub amount: i64,
    pub currency: String,
    pub fee_amount: i64,
    pub fee_currency: String,
    pub net_amount: i64,
    pub reference: Option<String>,
    #[serde(default)]
    pub available_psps: Vec<AvailableProvider>,
    #[serde(default)]
    pub branding: Metadata,
}

impl std::fmt::Debug for PaymentIntent {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        formatter
            .debug_struct("PaymentIntent")
            .field("id", &self.id)
            .field("org_id", &self.org_id)
            .field("connection_id", &self.connection_id)
            .field("provider", &self.provider)
            .field("provider_ref_id", &self.provider_ref_id)
            .field("status", &self.status)
            .field("client_secret", &"[REDACTED]")
            .field("session_secret", &"[REDACTED]")
            .field("psp_public_key", &self.psp_public_key)
            .field("psp_credentials", &"[REDACTED]")
            .field("amount", &self.amount)
            .field("currency", &self.currency)
            .field("reference", &self.reference)
            .finish_non_exhaustive()
    }
}

/// A provider available to handle a payment intent.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
pub struct AvailableProvider {
    pub provider: String,
    pub name: String,
    pub methods: Vec<String>,
    pub countries: Vec<String>,
}

/// A server-created session consumed by a Reevit browser SDK.
#[derive(Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct CheckoutSession {
    pub id: String,
    pub client_secret: String,
    pub session_secret: String,
    pub payment_intent: PaymentIntent,
    pub expires_at: Option<String>,
}

impl std::fmt::Debug for CheckoutSession {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        formatter
            .debug_struct("CheckoutSession")
            .field("id", &self.id)
            .field("client_secret", &"[REDACTED]")
            .field("session_secret", &"[REDACTED]")
            .field("payment_intent", &self.payment_intent)
            .field("expires_at", &self.expires_at)
            .finish()
    }
}

/// Offset pagination accepted by list operations.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
pub struct PaginationOptions {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<u32>,
}

/// Filters accepted when listing customers.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct CustomerListOptions {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub search: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_by: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_desc: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub currency: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub provider: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub payment_method: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub activity_status: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub min_spend: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_spend: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<String>,
}

/// Filters accepted when ranking customers.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
pub struct TopCustomerOptions {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metric: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub period: Option<String>,
}

/// Input used to create a customer.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct CreateCustomerRequest {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub external_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub phone: Option<String>,
    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
    pub metadata: Metadata,
}

/// Input used to update a customer.
pub type UpdateCustomerRequest = CreateCustomerRequest;

/// A Reevit customer.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct Customer {
    pub id: String,
    pub org_id: Option<String>,
    pub external_id: Option<String>,
    pub email: Option<String>,
    pub name: Option<String>,
    pub phone: Option<String>,
    #[serde(default)]
    pub metadata: Metadata,
    pub total_payments: Option<i64>,
    pub total_amount: Option<i64>,
    pub last_payment_at: Option<String>,
    pub created_at: Option<String>,
    pub updated_at: Option<String>,
    #[serde(default, flatten)]
    pub extra: Metadata,
}

/// A compact payment returned by list and history operations.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct PaymentSummary {
    pub id: String,
    pub connection_id: String,
    pub provider: String,
    pub reference: Option<String>,
    pub method: String,
    pub status: String,
    pub amount: i64,
    pub currency: String,
    pub fee_amount: i64,
    pub fee_currency: String,
    pub net_amount: i64,
    pub customer_id: String,
    #[serde(default)]
    pub metadata: Metadata,
    pub created_at: Option<String>,
    pub source: Option<String>,
    pub source_id: Option<String>,
    pub source_description: Option<String>,
}

/// Filters accepted when listing payments.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct PaymentListOptions {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub customer_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub provider: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub method: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub currency: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub search: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub amount_min: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub amount_max: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub from: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub to: Option<String>,
}

/// Input used to update a pending payment intent.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct UpdatePaymentIntentRequest {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub amount: Option<i64>,
    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
    pub metadata: Metadata,
}

/// A payment routing attempt.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct PaymentRouteAttempt {
    pub connection_id: String,
    pub provider: String,
    pub status: String,
    pub error: Option<String>,
    #[serde(default)]
    pub labels: Vec<String>,
    pub routing_hints: Option<RoutingHints>,
}

/// Routing hints attached to a connection or payment route.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
pub struct RoutingHints {
    pub country_preference: Vec<String>,
    pub method_bias: HashMap<String, String>,
    pub fallback_only: bool,
}

/// A complete Reevit payment.
#[derive(Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct Payment {
    pub id: String,
    pub connection_id: String,
    pub provider: String,
    pub provider_ref_id: Option<String>,
    pub reference: Option<String>,
    pub method: String,
    pub status: String,
    pub amount: i64,
    pub currency: String,
    pub fee_amount: i64,
    pub fee_currency: String,
    pub net_amount: i64,
    pub customer_id: Option<String>,
    pub client_secret: Option<String>,
    #[serde(default)]
    pub metadata: Metadata,
    #[serde(default)]
    pub route: Vec<PaymentRouteAttempt>,
    pub created_at: Option<String>,
    pub updated_at: Option<String>,
    pub source: Option<String>,
    pub source_id: Option<String>,
    pub source_description: Option<String>,
}

impl std::fmt::Debug for Payment {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        formatter
            .debug_struct("Payment")
            .field("id", &self.id)
            .field("connection_id", &self.connection_id)
            .field("provider", &self.provider)
            .field("provider_ref_id", &self.provider_ref_id)
            .field("reference", &self.reference)
            .field("method", &self.method)
            .field("status", &self.status)
            .field("amount", &self.amount)
            .field("currency", &self.currency)
            .field("client_secret", &"[REDACTED]")
            .finish_non_exhaustive()
    }
}

/// Input used to refund all or part of a payment.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
pub struct RefundRequest {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub amount: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reason: Option<String>,
}

/// A payment refund.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
pub struct Refund {
    pub id: String,
    pub payment_id: String,
    pub amount: i64,
    pub status: String,
    pub reason: Option<String>,
    pub created_at: Option<String>,
}

/// Filters accepted by aggregate payment statistics.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
pub struct PaymentStatsOptions {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub period: Option<String>,
}

/// One aggregate payment breakdown bucket.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
pub struct PaymentStatsBreakdown {
    pub key: String,
    pub count: i64,
    pub amount: i64,
}

/// Aggregate payment totals.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
pub struct PaymentStatsTotals {
    pub count: i64,
    pub amount: i64,
    pub succeeded: i64,
    pub failed: i64,
    pub refunded: i64,
}

/// Aggregate payment statistics.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct PaymentStats {
    pub totals: Option<PaymentStatsTotals>,
    pub by_provider: Vec<PaymentStatsBreakdown>,
    pub by_method: Vec<PaymentStatsBreakdown>,
    #[serde(flatten)]
    pub extra: Metadata,
}

/// Input used to create or test a PSP connection.
#[derive(Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct ConnectionRequest {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    pub provider: String,
    pub mode: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    pub credentials: Metadata,
    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
    pub capabilities: Metadata,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub routing_hints: Option<RoutingHints>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub labels: Vec<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub workflow_id: Option<String>,
}

impl std::fmt::Debug for ConnectionRequest {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        formatter
            .debug_struct("ConnectionRequest")
            .field("provider", &self.provider)
            .field("mode", &self.mode)
            .field("status", &self.status)
            .field("credentials", &"[REDACTED]")
            .field("capabilities", &self.capabilities)
            .field("routing_hints", &self.routing_hints)
            .field("labels", &self.labels)
            .field("workflow_id", &self.workflow_id)
            .finish()
    }
}

/// A configured PSP connection.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct Connection {
    pub id: String,
    pub provider: String,
    pub mode: String,
    pub status: String,
    #[serde(default)]
    pub capabilities: Metadata,
    pub routing_hints: Option<RoutingHints>,
    #[serde(default)]
    pub labels: Vec<String>,
    pub workflow_id: Option<String>,
    pub fee_structure: Option<ConnectionFeeStructure>,
    pub total_calls: Option<i64>,
    pub successful_calls: Option<i64>,
    pub failed_calls: Option<i64>,
    pub total_latency_ms: Option<i64>,
    pub last_success_at: Option<String>,
    pub last_failure_at: Option<String>,
    pub health_score: Option<f64>,
    pub health_status: Option<String>,
    pub last_validated_at: Option<String>,
    pub last_validation_status: Option<String>,
    pub last_validation_error: Option<String>,
    pub validation_failures: Option<u32>,
    pub name_match_status: Option<String>,
    pub created_at: Option<String>,
    pub updated_at: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct ConnectionFee {
    pub percentage: Option<f64>,
    pub fixed: Option<i64>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct ConnectionFeeStructure {
    pub percentage: Option<f64>,
    pub fixed: Option<i64>,
    #[serde(default)]
    pub per_method: HashMap<String, ConnectionFee>,
    #[serde(default)]
    pub per_currency: HashMap<String, ConnectionFee>,
}

/// Filters accepted when listing connections and their audit entries.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
pub struct ConnectionListOptions {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub provider: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mode: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub label: Option<String>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
pub struct ConnectionPagination {
    pub total: u64,
    pub limit: u32,
    pub offset: u32,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct ConnectionListPage {
    #[serde(default)]
    pub connections: Vec<Connection>,
    pub pagination: ConnectionPagination,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
pub struct ConnectionLabelStat {
    pub label: String,
    pub total: u64,
    #[serde(default)]
    pub providers: HashMap<String, u64>,
    #[serde(default)]
    pub statuses: HashMap<String, u64>,
}

/// One connection audit entry.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct ConnectionAuditEntry {
    pub id: Option<Value>,
    pub action: Option<String>,
    pub actor_id: Option<String>,
    pub actor_type: Option<String>,
    pub metadata: Metadata,
    pub created_at: Option<String>,
    #[serde(flatten)]
    pub extra: Metadata,
}

/// Input used to replace a connection's labels.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
pub struct ConnectionLabelsUpdate {
    pub labels: Vec<String>,
}

/// Input used to activate or deactivate a connection.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
pub struct ConnectionStatusUpdate {
    pub status: String,
}

/// Input used to create a subscription.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct SubscriptionRequest {
    pub customer_id: String,
    pub plan_id: String,
    pub amount: i64,
    pub currency: String,
    pub method: String,
    pub interval: String,
    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
    pub metadata: Metadata,
}

/// Input used to update a subscription.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct SubscriptionUpdateRequest {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub plan_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub amount: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interval: Option<String>,
    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
    pub metadata: Metadata,
}

/// Filters accepted when listing subscriptions.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
pub struct SubscriptionListOptions {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub customer_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub plan_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_after: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created_before: Option<String>,
}

/// A recurring Reevit subscription.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct Subscription {
    pub id: String,
    pub org_id: String,
    pub customer_id: String,
    pub plan_id: String,
    pub amount: i64,
    pub currency: String,
    pub method: String,
    pub interval: String,
    pub status: String,
    pub next_renewal_at: Option<String>,
    #[serde(default)]
    pub metadata: Metadata,
    pub created_at: Option<String>,
    pub updated_at: Option<String>,
}

/// Organization-level fraud routing policy.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
pub struct FraudPolicy {
    pub prefer: Vec<String>,
    pub max_amount: i64,
    pub blocked_bins: Vec<String>,
    pub allowed_bins: Vec<String>,
    pub velocity_max_per_minute: u32,
}

/// A hosted Reevit payment link.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct PaymentLink {
    pub id: String,
    pub code: Option<String>,
    pub name: Option<String>,
    pub title: Option<String>,
    pub description: Option<String>,
    pub url: Option<String>,
    pub status: Option<String>,
    pub amount: Option<i64>,
    pub currency: Option<String>,
    pub active: Option<bool>,
    pub reference: Option<String>,
    #[serde(default)]
    pub metadata: Metadata,
    pub created_at: Option<String>,
    pub updated_at: Option<String>,
    #[serde(default, flatten)]
    pub extra: Metadata,
}

/// Input used to create a hosted payment link.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct CreatePaymentLinkRequest {
    pub name: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    pub amount: i64,
    pub currency: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reference: Option<String>,
    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
    pub metadata: Metadata,
}

/// Input used to update a hosted payment link.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct UpdatePaymentLinkRequest {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub active: Option<bool>,
    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
    pub metadata: Metadata,
}

/// Filters accepted when listing hosted payment links.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
pub struct PaymentLinkListOptions {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub active: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub search: Option<String>,
}

/// Aggregate performance for one payment link.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct PaymentLinkStats {
    pub visits: i64,
    pub payments_count: i64,
    pub total_amount: i64,
    pub conversion_rate: f64,
    #[serde(flatten)]
    pub extra: Metadata,
}

/// A deterministic routing rule.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
pub struct RoutingRule {
    pub id: String,
    pub name: String,
    pub countries: Vec<String>,
    pub methods: Vec<String>,
    pub connection_id: String,
    pub priority: i32,
    pub fallback_to_default: bool,
    pub enabled: bool,
    pub created_at: Option<String>,
    pub updated_at: Option<String>,
}

/// Input used to create a routing rule.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
pub struct RoutingRuleCreateRequest {
    pub name: String,
    pub countries: Vec<String>,
    pub connection_id: String,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub methods: Vec<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub priority: Option<i32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fallback_to_default: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
}

/// Input used to update a routing rule.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
pub struct RoutingRuleUpdateRequest {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub countries: Option<Vec<String>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub methods: Option<Vec<String>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub connection_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub priority: Option<i32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fallback_to_default: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
}

/// A subscription invoice.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct Invoice {
    pub id: String,
    pub subscription_id: Option<String>,
    pub org_id: Option<String>,
    pub customer_id: Option<String>,
    pub amount: Option<i64>,
    pub currency: Option<String>,
    pub status: Option<String>,
    pub payment_id: Option<String>,
    pub due_at: Option<String>,
    pub due_date: Option<String>,
    #[serde(default)]
    pub metadata: Metadata,
    pub retry_count: Option<u32>,
    pub max_retries: Option<u32>,
    pub next_retry_at: Option<String>,
    pub created_at: Option<String>,
    pub updated_at: Option<String>,
    #[serde(default, flatten)]
    pub extra: Metadata,
}

/// Filters accepted when listing invoices.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
pub struct InvoiceListOptions {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub subscription_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub customer_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
}

/// Input used to update an invoice.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct InvoiceUpdateRequest {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub due_at: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub due_date: Option<String>,
    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
    pub metadata: Metadata,
}

/// Organization-level outbound webhook configuration.
#[derive(Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct WebhookConfig {
    pub id: Option<String>,
    pub url: String,
    pub status: Option<String>,
    #[serde(default)]
    pub events: Vec<String>,
    pub signing_secret: Option<String>,
    pub org_id: Option<String>,
    #[serde(default)]
    pub metadata: Metadata,
    pub created_at: Option<String>,
    pub updated_at: Option<String>,
}

impl std::fmt::Debug for WebhookConfig {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        formatter
            .debug_struct("WebhookConfig")
            .field("id", &self.id)
            .field("url", &self.url)
            .field("status", &self.status)
            .field("events", &self.events)
            .field("signing_secret", &"[REDACTED]")
            .field("org_id", &self.org_id)
            .field("metadata", &self.metadata)
            .field("created_at", &self.created_at)
            .field("updated_at", &self.updated_at)
            .finish()
    }
}

/// Input used to create or update outbound webhook configuration.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct WebhookConfigRequest {
    pub url: String,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub events: Vec<String>,
    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
    pub metadata: Metadata,
}

/// Filters accepted when listing webhook events.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
pub struct WebhookEventListOptions {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub provider: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub event_type: Option<String>,
    #[serde(rename = "type", skip_serializing_if = "Option::is_none")]
    pub kind: Option<String>,
}

/// A recorded webhook event.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct WebhookEvent {
    pub id: String,
    #[serde(rename = "type")]
    pub kind: Option<String>,
    pub provider: Option<String>,
    pub event_type: Option<String>,
    pub status: Option<String>,
    pub attempt_count: Option<u32>,
    #[serde(default)]
    pub data: Metadata,
    #[serde(default)]
    pub payload: Metadata,
    pub created_at: Option<String>,
    pub updated_at: Option<String>,
    #[serde(default, flatten)]
    pub extra: Metadata,
}

/// An outbound webhook delivery.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
pub struct OutboundWebhook {
    pub id: String,
    pub event_id: Option<String>,
    pub event_type: Option<String>,
    pub url: Option<String>,
    pub target_url: Option<String>,
    pub status: Option<String>,
    pub response_code: Option<u16>,
    pub attempts: Option<u32>,
    pub attempt_count: Option<u32>,
    pub created_at: Option<String>,
    pub updated_at: Option<String>,
    #[serde(default, flatten)]
    pub extra: Metadata,
}