models.rs

use std::collections::HashMap;

pub use breez_sdk_spark::passkey::*;
pub use breez_sdk_spark::signer::*;
pub use breez_sdk_spark::sync_storage::*;
pub use breez_sdk_spark::*;
use flutter_rust_bridge::frb;

#[frb(mirror(BitcoinAddressDetails))]
pub struct _BitcoinAddressDetails {
    pub address: String,
    pub network: BitcoinNetwork,
    pub source: PaymentRequestSource,
}

#[frb(mirror(BitcoinNetwork))]
pub enum _BitcoinNetwork {
    Bitcoin,
    Testnet3,
    Testnet4,
    Signet,
    Regtest,
}

#[frb(mirror(Config))]
pub struct _Config {
    pub api_key: Option<String>,
    pub network: Network,
    pub sync_interval_secs: u32,
    pub max_deposit_claim_fee: Option<MaxFee>,
    pub max_instant_deposit_claim_fee_bps: Option<u32>,
    pub lnurl_domain: Option<String>,
    pub prefer_spark_over_lightning: bool,
    pub exit_chain_auto_fetch_enabled: bool,
    pub external_input_parsers: Option<Vec<ExternalInputParser>>,
    pub use_default_external_input_parsers: bool,
    pub real_time_sync_server_url: Option<String>,
    pub private_enabled_default: bool,
    pub leaf_optimization_config: LeafOptimizationConfig,
    pub token_optimization_config: TokenOptimizationConfig,
    pub stable_balance_config: Option<StableBalanceConfig>,
    /// Maximum number of concurrent transfer claims.
    ///
    /// Controls how many pending Spark transfers can be claimed in parallel.
    /// Default is 4. Increase for server environments with high incoming
    /// payment volume to improve throughput.
    pub max_concurrent_claims: u32,
    pub spark_config: Option<SparkConfig>,
    pub background_tasks_enabled: bool,
    pub cross_chain_config: Option<CrossChainConfig>,
}

#[frb(mirror(CrossChainConfig))]
pub struct _CrossChainConfig {
    pub default_slippage_bps: Option<u32>,
    pub default_target_overpay_bps: Option<u32>,
}

#[frb(mirror(SparkConfig))]
pub struct _SparkConfig {
    pub coordinator_identifier: String,
    pub threshold: u32,
    pub signing_operators: Vec<SparkSigningOperator>,
    pub ssp_config: SparkSspConfig,
    pub expected_withdraw_bond_sats: u64,
    pub expected_withdraw_relative_block_locktime: u64,
    pub max_token_transaction_inputs: Option<u32>,
}

#[frb(mirror(SparkSigningOperator))]
pub struct _SparkSigningOperator {
    pub id: u32,
    pub identifier: String,
    pub address: String,
    pub identity_public_key: String,
    pub ca_cert_pem: Option<String>,
}

#[frb(mirror(SparkSspConfig))]
pub struct _SparkSspConfig {
    pub base_url: String,
    pub identity_public_key: String,
    pub schema_endpoint: Option<String>,
}

#[frb(mirror(LeafOptimizationConfig))]
pub struct _LeafOptimizationConfig {
    pub auto_enabled: bool,
    pub multiplicity: u8,
}

#[frb(mirror(TokenOptimizationConfig))]
pub struct _TokenOptimizationConfig {
    pub auto_enabled: bool,
    pub target_output_count: u32,
    pub min_outputs_threshold: u32,
}

#[frb(mirror(StableBalanceToken))]
pub struct _StableBalanceToken {
    pub label: String,
    pub token_identifier: String,
}

#[frb(mirror(StableBalanceConfig))]
pub struct _StableBalanceConfig {
    pub tokens: Vec<StableBalanceToken>,
    pub default_active_label: Option<String>,
    pub threshold_sats: Option<u64>,
    pub max_slippage_bps: Option<u32>,
}

#[frb(mirror(ExternalInputParser))]
pub struct _ExternalInputParser {
    pub provider_id: String,
    pub input_regex: String,
    pub parser_url: String,
}

#[frb(mirror(Seed))]
pub enum _Seed {
    Mnemonic {
        mnemonic: String,
        passphrase: Option<String>,
    },
    Entropy(Vec<u8>),
}

#[frb(mirror(ConnectRequest))]
pub struct _ConnectRequest {
    pub config: Config,
    pub seed: Seed,
    pub storage_dir: String,
}

#[frb(mirror(CheckMessageRequest))]
pub struct _CheckMessageRequest {
    pub message: String,
    pub pubkey: String,
    pub signature: String,
}

#[frb(mirror(CheckMessageResponse))]
pub struct _CheckMessageResponse {
    pub is_valid: bool,
}

#[frb(mirror(ClaimDepositRequest))]
pub struct _ClaimDepositRequest {
    pub txid: String,
    pub vout: u32,
    pub max_fee: Option<MaxFee>,
    pub max_instant_fee_bps: Option<u32>,
}

#[frb(mirror(ClaimDepositResponse))]
pub struct _ClaimDepositResponse {
    pub payment: Option<Payment>,
}

#[frb(mirror(Credentials))]
pub struct _Credentials {
    pub username: String,
    pub password: String,
}

#[frb(mirror(InstantClaimDeclineReason))]
pub enum _InstantClaimDeclineReason {
    NoPlan,
    FeeExceeded {
        max_bps: u32,
        quoted_bps: u32,
        quoted_sats: u64,
    },
    SubmissionFailed,
}

#[frb(mirror(InstantClaimStatus))]
pub enum _InstantClaimStatus {
    Declined { reason: InstantClaimDeclineReason },
    Submitted { claim_id: String },
}

#[frb(mirror(DepositInfo))]
pub struct _DepositInfo {
    pub txid: String,
    pub vout: u32,
    pub amount_sats: u64,
    pub is_mature: bool,
    pub refund_tx: Option<String>,
    pub refund_tx_id: Option<String>,
    pub claim_error: Option<DepositClaimError>,
    pub instant_claim_status: Option<InstantClaimStatus>,
}

#[frb(mirror(MaxFee))]
pub enum _MaxFee {
    Fixed { amount: u64 },
    Rate { sat_per_vbyte: u64 },
    NetworkRecommended { leeway_sat_per_vbyte: u64 },
}

#[frb(mirror(Fee))]
pub enum _Fee {
    Fixed { amount: u64 },
    Rate { sat_per_vbyte: u64 },
}

#[frb(mirror(CpfpInput))]
pub enum _CpfpInput {
    P2wpkh {
        txid: String,
        vout: u32,
        value: u64,
        pubkey: String,
    },
    P2tr {
        txid: String,
        vout: u32,
        value: u64,
        pubkey: String,
    },
    Custom {
        txid: String,
        vout: u32,
        value: u64,
        script_pubkey_hex: String,
        signed_input_weight: u64,
    },
}

#[frb(mirror(CpfpFundingKind))]
pub enum _CpfpFundingKind {
    P2wpkh,
    P2tr,
    Custom {
        script_pubkey_hex: String,
        signed_input_weight: u64,
    },
}

#[frb(mirror(ExitLeafSelection))]
pub enum _ExitLeafSelection {
    Auto,
    Specific { leaf_ids: Vec<String> },
}

#[frb(mirror(UnilateralExitTxKind))]
pub enum _UnilateralExitTxKind {
    FanOut,
    Node,
    Refund,
    Sweep,
}

#[frb(mirror(ConfirmationStatus))]
pub enum _ConfirmationStatus {
    Confirmed,
    Unconfirmed,
    Unverified,
}

#[frb(mirror(UnilateralExitTransaction))]
pub struct _UnilateralExitTransaction {
    pub kind: UnilateralExitTxKind,
    pub node_id: Option<String>,
    pub txid: String,
    pub tx_hex: String,
    pub cpfp_tx_hex: Option<String>,
    pub csv_timelock_blocks: Option<u32>,
    pub depends_on: Vec<String>,
    pub status: ConfirmationStatus,
}

#[frb(mirror(UnilateralExitLeaf))]
pub struct _UnilateralExitLeaf {
    pub leaf_id: String,
    pub value: u64,
}

#[frb(mirror(PerBranchFunding))]
pub struct _PerBranchFunding {
    pub leaf_id: String,
    pub funding_sat: u64,
}

#[frb(mirror(PrepareUnilateralExitRequest))]
pub struct _PrepareUnilateralExitRequest {
    pub fee_rate_sat_per_vbyte: u64,
    pub funding_kind: CpfpFundingKind,
    pub destination: String,
    pub selection: ExitLeafSelection,
}

#[frb(mirror(PrepareUnilateralExitResponse))]
pub struct _PrepareUnilateralExitResponse {
    pub leaves: Vec<UnilateralExitLeaf>,
    pub recoverable_value_sat: u64,
    pub total_fee_sat: u64,
    pub fanout_fee_sat: u64,
    pub single_utxo_funding_sat: u64,
    pub per_branch_funding: Vec<PerBranchFunding>,
    pub fee_rate_sat_per_vbyte: u64,
    pub destination: String,
}

#[frb(mirror(UnilateralExitRequest))]
pub struct _UnilateralExitRequest {
    pub prepared: PrepareUnilateralExitResponse,
    pub funding_inputs: Vec<CpfpInput>,
}

#[frb(mirror(UnilateralExitResponse))]
pub struct _UnilateralExitResponse {
    pub recoverable_value_sat: u64,
    pub total_fee_sat: u64,
    pub leaves: Vec<UnilateralExitLeaf>,
    pub transactions: Vec<UnilateralExitTransaction>,
}

#[frb(mirror(ExportUnilateralExitStateResponse))]
pub struct _ExportUnilateralExitStateResponse {
    pub exit_state: String,
}

#[frb(mirror(ImportUnilateralExitStateRequest))]
pub struct _ImportUnilateralExitStateRequest {
    pub exit_state: String,
}

#[frb(mirror(ImportUnilateralExitStateResponse))]
pub struct _ImportUnilateralExitStateResponse {
    pub imported_leaves: u32,
    pub skipped_foreign_leaves: u32,
    pub skipped_conflicting_leaves: u32,
    pub skipped_chains: u32,
}

#[frb(mirror(GetInfoRequest))]
pub struct _GetInfoRequest {
    pub ensure_synced: Option<bool>,
}

#[frb(mirror(GetInfoResponse))]
pub struct _GetInfoResponse {
    pub identity_pubkey: String,
    pub balance_sats: u64,
    pub token_balances: HashMap<String, TokenBalance>,
}

#[frb(mirror(TokenBalance))]
pub struct _TokenBalance {
    pub balance: u128,
    pub token_metadata: TokenMetadata,
}

#[frb(mirror(TokenMetadata))]
pub struct _TokenMetadata {
    pub identifier: String,
    pub issuer_public_key: String,
    pub name: String,
    pub ticker: String,
    pub decimals: u32,
    pub max_supply: u128,
    pub is_freezable: bool,
}

#[frb(mirror(GetPaymentRequest))]
pub struct _GetPaymentRequest {
    pub payment_id: String,
}

#[frb(mirror(GetPaymentResponse))]
pub struct _GetPaymentResponse {
    pub payment: Payment,
}

#[frb(mirror(GetLightningReceiveRequestRequest))]
pub struct _GetLightningReceiveRequestRequest {
    pub request_id: String,
}

#[frb(mirror(GetLightningReceiveRequestResponse))]
pub struct _GetLightningReceiveRequestResponse {
    pub id: String,
    pub status: LightningReceiveStatus,
    pub invoice: String,
    pub created_at: i64,
    pub updated_at: i64,
    pub transfer_id: Option<String>,
    pub transfer_amount_sat: Option<u64>,
    pub payment_preimage: Option<String>,
}

#[frb(mirror(GetPaymentByInvoiceRequest))]
pub struct _GetPaymentByInvoiceRequest {
    pub invoice: String,
}

#[frb(mirror(GetPaymentByInvoiceResponse))]
pub struct _GetPaymentByInvoiceResponse {
    pub payment: Option<Payment>,
}

#[frb(mirror(InputType))]
pub enum _InputType {
    BitcoinAddress(BitcoinAddressDetails),
    Bolt11Invoice(Bolt11InvoiceDetails),
    Bolt12Invoice(Bolt12InvoiceDetails),
    Bolt12Offer(Bolt12OfferDetails),
    LightningAddress(LightningAddressDetails),
    LnurlPay(LnurlPayRequestDetails),
    SilentPaymentAddress(SilentPaymentAddressDetails),
    LnurlAuth(LnurlAuthRequestDetails),
    Url(String),
    Bip21(Bip21Details),
    Bolt12InvoiceRequest(Bolt12InvoiceRequestDetails),
    LnurlWithdraw(LnurlWithdrawRequestDetails),
    SparkAddress(SparkAddressDetails),
    SparkInvoice(SparkInvoiceDetails),
    CrossChainAddress(CrossChainAddressDetails),
}

#[frb(mirror(CrossChainAddressFamily))]
pub enum _CrossChainAddressFamily {
    Evm,
    Solana,
    Tron,
}

#[frb(mirror(CrossChainAddressDetails))]
pub struct _CrossChainAddressDetails {
    pub address: String,
    pub address_family: CrossChainAddressFamily,
    pub contract_address: Option<String>,
    pub chain_id: Option<u64>,
    pub amount: Option<u128>,
}

#[frb(mirror(SourceAsset))]
pub enum _SourceAsset {
    Bitcoin,
    Token { token_identifier: String },
}

#[frb(mirror(SourceChain))]
pub enum _SourceChain {
    Spark,
    Lightning,
    Bitcoin,
}

#[frb(mirror(CrossChainFeeMode))]
pub enum _CrossChainFeeMode {
    FeesExcluded,
    FeesIncluded,
}

#[frb(mirror(CrossChainRoutePair))]
pub struct _CrossChainRoutePair {
    pub provider: CrossChainProvider,
    pub chain: String,
    pub chain_id: Option<String>,
    pub asset: String,
    pub contract_address: Option<String>,
    pub decimals: u8,
    pub exact_out_eligible: bool,
    pub supported_sources: Vec<SourceAsset>,
    pub supported_source_chains: Vec<SourceChain>,
}

#[frb(mirror(CrossChainProviderContext))]
pub enum _CrossChainProviderContext {
    Orchestra {
        quote_id: String,
        deposit_address: String,
        deposit_amount: u128,
    },
    Boltz {
        swap_id: String,
        invoice: String,
        invoice_amount_sats: u64,
        max_slippage_bps: u32,
    },
}

#[frb(mirror(CrossChainRouteFilter))]
pub enum _CrossChainRouteFilter {
    Send {
        address_details: CrossChainAddressDetails,
    },
    Receive {
        contract_address: Option<String>,
    },
    PaymentLink {
        address_details: CrossChainAddressDetails,
    },
}

#[frb(mirror(PaymentDetailsFilter))]
pub enum _PaymentDetailsFilter {
    Spark {
        htlc_status: Option<Vec<SparkHtlcStatus>>,
        conversion_refund_needed: Option<bool>,
    },
    Token {
        conversion_refund_needed: Option<bool>,
        tx_hash: Option<String>,
        tx_type: Option<TokenTransactionType>,
    },
    Lightning {
        htlc_status: Option<Vec<SparkHtlcStatus>>,
    },
}

#[frb(mirror(ListPaymentsRequest))]
pub struct _ListPaymentsRequest {
    pub type_filter: Option<Vec<PaymentType>>,
    pub status_filter: Option<Vec<PaymentStatus>>,
    pub asset_filter: Option<AssetFilter>,
    pub payment_details_filter: Option<Vec<PaymentDetailsFilter>>,
    pub from_timestamp: Option<u64>,
    pub to_timestamp: Option<u64>,
    pub offset: Option<u32>,
    pub limit: Option<u32>,
    pub sort_ascending: Option<bool>,
}

#[frb(mirror(AssetFilter))]
pub enum _AssetFilter {
    Bitcoin,
    Token { token_identifier: Option<String> },
}

#[frb(mirror(ListPaymentsResponse))]
pub struct _ListPaymentsResponse {
    pub payments: Vec<Payment>,
}

#[frb(mirror(ListUnclaimedDepositsRequest))]
pub struct _ListUnclaimedDepositsRequest {}

#[frb(mirror(ListUnclaimedDepositsResponse))]
pub struct _ListUnclaimedDepositsResponse {
    pub deposits: Vec<DepositInfo>,
}

#[frb(mirror(LnurlPayInfo))]
pub struct _LnurlPayInfo {
    pub ln_address: Option<String>,
    pub comment: Option<String>,
    pub domain: Option<String>,
    pub metadata: Option<String>,
    pub processed_success_action: Option<SuccessActionProcessed>,
    pub raw_success_action: Option<SuccessAction>,
}

#[frb(mirror(LnurlPayRequest))]
pub struct _LnurlPayRequest {
    pub prepare_response: PrepareLnurlPayResponse,
    pub idempotency_key: Option<String>,
}

#[frb(mirror(LnurlPayResponse))]
pub struct _LnurlPayResponse {
    pub payment: Payment,
    pub success_action: Option<SuccessActionProcessed>,
}

#[frb(mirror(LnurlWithdrawInfo))]
pub struct _LnurlWithdrawInfo {
    pub withdraw_url: String,
}

#[frb(mirror(LnurlReceiveMetadata))]
pub struct _LnurlReceiveMetadata {
    pub nostr_zap_request: Option<String>,
    pub nostr_zap_receipt: Option<String>,
    pub sender_comment: Option<String>,
}

#[frb(mirror(LnurlWithdrawRequest))]
pub struct _LnurlWithdrawRequest {
    pub amount_sats: u64,
    pub withdraw_request: LnurlWithdrawRequestDetails,
    pub completion_timeout_secs: Option<u32>,
}

#[frb(mirror(LnurlWithdrawResponse))]
pub struct _LnurlWithdrawResponse {
    pub payment_request: String,
    pub payment: Option<Payment>,
}

#[frb(mirror(LnurlErrorDetails))]
pub struct _LnurlErrorDetails {
    pub reason: String,
}

#[frb(mirror(LnurlCallbackStatus))]
pub enum _LnurlCallbackStatus {
    Ok,
    ErrorStatus { error_details: LnurlErrorDetails },
}

#[frb(mirror(OnchainConfirmationSpeed))]
pub enum _OnchainConfirmationSpeed {
    Fast,
    Medium,
    Slow,
}

#[frb(mirror(FeePolicy))]
pub enum _FeePolicy {
    /// Fees are added on top of the specified amount (default behavior).
    FeesExcluded,
    /// Fees are deducted from the specified amount.
    FeesIncluded,
}

#[frb(mirror(PrepareLnurlPayRequest))]
pub struct _PrepareLnurlPayRequest {
    pub amount: u128,
    pub pay_request: LnurlPayRequestDetails,
    pub comment: Option<String>,
    pub validate_success_action_url: Option<bool>,
    pub token_identifier: Option<String>,
    pub conversion_options: Option<ConversionOptions>,
    pub fee_policy: Option<FeePolicy>,
}

#[frb(mirror(PrepareLnurlPayResponse))]
pub struct _PrepareLnurlPayResponse {
    pub amount_sats: u64,
    pub comment: Option<String>,
    pub pay_request: LnurlPayRequestDetails,
    pub fee_sats: u64,
    pub invoice_details: Bolt11InvoiceDetails,
    pub success_action: Option<SuccessAction>,
    pub conversion_estimate: Option<ConversionEstimate>,
    pub fee_policy: FeePolicy,
}

#[frb(mirror(PaymentRequest))]
pub enum _PaymentRequest {
    Input {
        input: String,
    },
    CrossChain {
        address: String,
        route: CrossChainRoutePair,
        max_slippage_bps: Option<u32>,
        target_overpay_bps: Option<u32>,
    },
}

#[frb(mirror(CrossChainProvider))]
pub enum _CrossChainProvider {
    Orchestra,
    Boltz,
}

#[frb(mirror(ExternalTreeNodeId))]
pub struct _ExternalTreeNodeId {
    pub id: String,
}

#[frb(mirror(ExternalIdentifier))]
pub struct _ExternalIdentifier {
    pub bytes: Vec<u8>,
}

#[frb(mirror(EcdsaSignatureBytes))]
pub struct _EcdsaSignatureBytes {
    pub bytes: Vec<u8>,
}

#[frb(mirror(ExternalTransferLeafInput))]
pub struct _ExternalTransferLeafInput {
    pub node_id: ExternalTreeNodeId,
    pub new_leaf_id: ExternalTreeNodeId,
}

#[frb(mirror(ExternalOperatorRecipient))]
pub struct _ExternalOperatorRecipient {
    pub id: u64,
    pub identifier: ExternalIdentifier,
    pub public_key: Vec<u8>,
}

#[frb(mirror(ExternalOperatorPackage))]
pub struct _ExternalOperatorPackage {
    pub operator_identifier: ExternalIdentifier,
    pub encrypted_package: Vec<u8>,
}

#[frb(mirror(ExternalNewLeafKey))]
pub struct _ExternalNewLeafKey {
    pub node_id: ExternalTreeNodeId,
    pub new_signing_public_key: Vec<u8>,
}

#[frb(mirror(ExternalPrepareTransferRequest))]
pub struct _ExternalPrepareTransferRequest {
    pub transfer_id: String,
    pub receiver_public_key: Vec<u8>,
    pub leaves: Vec<ExternalTransferLeafInput>,
    pub operator_recipients: Vec<ExternalOperatorRecipient>,
    pub threshold: u32,
}

#[frb(mirror(ExternalPreparedTransfer))]
pub struct _ExternalPreparedTransfer {
    pub operator_packages: Vec<ExternalOperatorPackage>,
    pub new_leaf_keys: Vec<ExternalNewLeafKey>,
    pub transfer_user_signature: EcdsaSignatureBytes,
}

#[frb(mirror(SchnorrSignatureBytes))]
pub struct _SchnorrSignatureBytes {
    pub bytes: Vec<u8>,
}

#[frb(mirror(ExternalTokenTransactionKind))]
pub enum _ExternalTokenTransactionKind {
    Freeze,
    Partial,
    Final,
}

#[frb(mirror(ExternalPrepareTokenTransactionRequest))]
pub struct _ExternalPrepareTokenTransactionRequest {
    pub kind: ExternalTokenTransactionKind,
    pub digest: Vec<u8>,
}

#[frb(mirror(ExternalPreparedTokenTransaction))]
pub struct _ExternalPreparedTokenTransaction {
    pub signature: SchnorrSignatureBytes,
}

#[frb(mirror(UnsignedTransferPackage))]
pub enum _UnsignedTransferPackage {
    Swap {
        prepare_transfer: ExternalPrepareTransferRequest,
        target_amounts: Vec<u64>,
        amount_sat: u64,
        fee_sat: u64,
    },
    Transfer {
        prepare_transfer: ExternalPrepareTransferRequest,
        amount_sat: u64,
        fee_sat: u64,
        target: TransferTarget,
    },
    Token {
        prepare_token_transaction: ExternalPrepareTokenTransactionRequest,
        token_context: Vec<u8>,
        token_identifier: String,
        amount: u128,
        fee: u128,
        is_swap: bool,
    },
    TokenBatch {
        prepare_token_transaction: ExternalPrepareTokenTransactionRequest,
        token_context: Vec<u8>,
        totals: Vec<BatchTotal>,
        is_swap: bool,
    },
}

#[frb(mirror(TransferTarget))]
pub enum _TransferTarget {
    Spark {
        address: String,
        spark_invoice: Option<String>,
    },
    Lightning {
        bolt11: String,
        lnurl_pay: Option<LnurlPayContext>,
        fee_policy: FeePolicy,
        completion_timeout_secs: Option<u32>,
    },
    CoopExit {
        address: String,
        fee_quote: SendOnchainFeeQuote,
        confirmation_speed: OnchainConfirmationSpeed,
    },
}

#[frb(mirror(LnurlPayContext))]
pub struct _LnurlPayContext {
    pub pay_request: LnurlPayRequestDetails,
    pub comment: Option<String>,
    pub success_action: Option<SuccessAction>,
}

#[frb(mirror(SignedTransferPackage))]
pub struct _SignedTransferPackage {
    pub unsigned: UnsignedTransferPackage,
    pub signature: TransferSignature,
}

#[frb(mirror(TransferSignature))]
pub enum _TransferSignature {
    Transfer {
        signed: ExternalPreparedTransfer,
    },
    Token {
        signed: ExternalPreparedTokenTransaction,
    },
}

#[frb(mirror(BuildTransferPackageOptions))]
pub enum _BuildTransferPackageOptions {
    BitcoinAddress {
        confirmation_speed: OnchainConfirmationSpeed,
    },
    Bolt11Invoice {
        prefer_spark: bool,
        completion_timeout_secs: Option<u32>,
    },
}

#[frb(mirror(BuildUnsignedTransferPackageRequest))]
pub struct _BuildUnsignedTransferPackageRequest {
    pub prepare_response: PrepareSendPaymentResponse,
    pub options: Option<BuildTransferPackageOptions>,
}

#[frb(mirror(PrepareSendPaymentRequest))]
pub struct _PrepareSendPaymentRequest {
    pub payment_request: PaymentRequest,
    pub amount: Option<u128>,
    pub token_identifier: Option<String>,
    pub conversion_options: Option<ConversionOptions>,
    pub fee_policy: Option<FeePolicy>,
}

#[frb(mirror(PrepareSendPaymentResponse))]
pub struct _PrepareSendPaymentResponse {
    pub payment_method: SendPaymentMethod,
    pub amount: u128,
    pub token_identifier: Option<String>,
    pub conversion_estimate: Option<ConversionEstimate>,
    pub fee_policy: FeePolicy,
}

#[frb(mirror(ReceivePaymentMethod))]
pub enum _ReceivePaymentMethod {
    SparkAddress,
    SparkInvoice {
        amount: Option<u128>,
        token_identifier: Option<String>,
        expiry_time: Option<u64>,
        description: Option<String>,
        sender_public_key: Option<String>,
    },
    BitcoinAddress {
        new_address: Option<bool>,
    },
    Bolt11Invoice {
        description: String,
        amount_sats: Option<u64>,
        expiry_secs: Option<u32>,
        payment_hash: Option<String>,
        receiver_identity_public_key: Option<String>,
        description_hash: Option<String>,
    },
}

#[frb(mirror(ReceivePaymentRequest))]
pub struct _ReceivePaymentRequest {
    pub payment_method: ReceivePaymentMethod,
}

#[frb(mirror(ReceivePaymentResponse))]
pub struct _ReceivePaymentResponse {
    pub payment_request: String,
    pub fee: u128,
    pub lightning_receive_details: Option<LightningReceiveDetails>,
}

#[frb(mirror(LightningReceiveDetails))]
pub struct _LightningReceiveDetails {
    pub receive_request_id: String,
    pub status: LightningReceiveStatus,
    pub created_at: i64,
    pub updated_at: i64,
}

#[frb(mirror(LightningReceiveStatus))]
pub enum _LightningReceiveStatus {
    InvoiceCreated,
    HtlcReceived,
    TransferCreated,
    TransferCreationFailed,
    PaymentPreimagePending,
    PaymentPreimageRecovered,
    PaymentPreimageQueryingFailed,
    PaymentPreimageRecoveringFailed,
    TransferCanceled,
    HtlcFailed,
    LightningPaymentReceived,
    TransferFailed,
    TransferCompleted,
    RefundSigningCommitmentsQueryingFailed,
    RefundSigningFailed,
    Unknown,
}

#[frb(mirror(RefundDepositRequest))]
pub struct _RefundDepositRequest {
    pub txid: String,
    pub vout: u32,
    pub destination_address: String,
    pub fee: Fee,
}

#[frb(mirror(RefundDepositResponse))]
pub struct _RefundDepositResponse {
    pub tx_id: String,
    pub tx_hex: String,
}

#[frb(mirror(SendOnchainFeeQuote))]
pub struct _SendOnchainFeeQuote {
    pub id: String,
    pub expires_at: u64,
    pub speed_fast: SendOnchainSpeedFeeQuote,
    pub speed_medium: SendOnchainSpeedFeeQuote,
    pub speed_slow: SendOnchainSpeedFeeQuote,
}

#[frb(mirror(SendOnchainSpeedFeeQuote))]
pub struct _SendOnchainSpeedFeeQuote {
    pub user_fee_sat: u64,
    pub l1_broadcast_fee_sat: u64,
}

#[frb(mirror(SendPaymentMethod))]
pub enum _SendPaymentMethod {
    BitcoinAddress {
        address: BitcoinAddressDetails,
        fee_quote: SendOnchainFeeQuote,
    },
    Bolt11Invoice {
        invoice_details: Bolt11InvoiceDetails,
        spark_transfer_fee_sats: Option<u64>,
        lightning_fee_sats: u64,
    },
    SparkAddress {
        address: String,
        fee: u128,
        token_identifier: Option<String>,
    },
    SparkInvoice {
        spark_invoice_details: SparkInvoiceDetails,
        fee: u128,
        token_identifier: Option<String>,
    },
    CrossChainAddress {
        route: CrossChainRoutePair,
        recipient_address: String,
        amount_in: u128,
        asset_amount_in: u128,
        estimated_out: u128,
        fee_amount: u128,
        service_fee_amount: u128,
        service_fee_asset: Option<String>,
        source_transfer_fee_sats: u64,
        fee_mode: CrossChainFeeMode,
        expires_at: String,
        provider_context: CrossChainProviderContext,
    },
}

#[frb(mirror(SendPaymentOptions))]
pub enum _SendPaymentOptions {
    BitcoinAddress {
        confirmation_speed: OnchainConfirmationSpeed,
    },
    Bolt11Invoice {
        prefer_spark: bool,
        completion_timeout_secs: Option<u32>,
    },
    SparkAddress {
        htlc_options: Option<SparkHtlcOptions>,
    },
}

#[frb(mirror(SparkHtlcOptions))]
pub struct _SparkHtlcOptions {
    pub payment_hash: String,
    pub expiry_duration_secs: u64,
}

#[frb(mirror(SendPaymentRequest))]
pub struct _SendPaymentRequest {
    pub prepare_response: PrepareSendPaymentResponse,
    pub options: Option<SendPaymentOptions>,
    pub idempotency_key: Option<String>,
}

#[frb(mirror(PublishSignedTransferPackageRequest))]
pub struct _PublishSignedTransferPackageRequest {
    pub signed_package: SignedTransferPackage,
}

#[frb(mirror(PublishSignedTransferPackageResponse))]
pub enum _PublishSignedTransferPackageResponse {
    SwapCompleted,
    PaymentSent { payment: Payment },
    PaymentsSent { payments: Vec<Payment> },
}

#[frb(mirror(BatchRecipient))]
pub struct _BatchRecipient {
    pub payment_request: String,
    pub amount: Option<u128>,
    pub token_identifier: Option<String>,
}

#[frb(mirror(PrepareSendBatchRequest))]
pub struct _PrepareSendBatchRequest {
    pub recipients: Vec<BatchRecipient>,
}

#[frb(mirror(BatchDestination))]
pub enum _BatchDestination {
    SparkAddress {
        address: String,
    },
    SparkInvoice {
        invoice_details: SparkInvoiceDetails,
    },
}

#[frb(mirror(ResolvedBatchRecipient))]
pub struct _ResolvedBatchRecipient {
    pub destination: BatchDestination,
    pub amount: u128,
    pub token_identifier: Option<String>,
}

#[frb(mirror(BatchTotal))]
pub struct _BatchTotal {
    pub token_identifier: Option<String>,
    pub amount: u128,
}

#[frb(mirror(PrepareSendBatchResponse))]
pub struct _PrepareSendBatchResponse {
    pub recipients: Vec<ResolvedBatchRecipient>,
    pub totals: Vec<BatchTotal>,
}

#[frb(mirror(SendBatchRequest))]
pub struct _SendBatchRequest {
    pub prepare_response: PrepareSendBatchResponse,
}

#[frb(mirror(SendBatchResponse))]
pub struct _SendBatchResponse {
    pub payments: Vec<Payment>,
}

#[frb(mirror(BuildUnsignedBatchPackageRequest))]
pub struct _BuildUnsignedBatchPackageRequest {
    pub prepare_response: PrepareSendBatchResponse,
}

#[frb(mirror(BuildUnsignedLnurlPayPackageRequest))]
pub struct _BuildUnsignedLnurlPayPackageRequest {
    pub prepare_response: PrepareLnurlPayResponse,
}

#[frb(mirror(PublishSignedLnurlPayPackageRequest))]
pub struct _PublishSignedLnurlPayPackageRequest {
    pub signed_package: SignedTransferPackage,
}

#[frb(mirror(PublishSignedLnurlPayResponse))]
pub enum _PublishSignedLnurlPayResponse {
    SwapCompleted,
    PaymentSent { response: LnurlPayResponse },
}

#[frb(mirror(SendPaymentResponse))]
pub struct _SendPaymentResponse {
    pub payment: Payment,
    pub lightning_send_details: Option<LightningSendDetails>,
}

#[frb(mirror(LightningSendDetails))]
pub struct _LightningSendDetails {
    pub send_request_id: String,
    pub status: LightningSendStatus,
    pub created_at: i64,
    pub updated_at: i64,
}

#[frb(mirror(LightningSendStatus))]
pub enum _LightningSendStatus {
    Created,
    UserTransferValidationFailed,
    LightningPaymentInitiated,
    LightningPaymentFailed,
    LightningPaymentSucceeded,
    PreimageProvided,
    PreimageProvidingFailed,
    TransferCompleted,
    TransferFailed,
    PendingUserSwapReturn,
    UserSwapReturned,
    UserSwapReturnFailed,
    RequestValidated,
    Unknown,
}

#[frb(mirror(SignMessageRequest))]
pub struct _SignMessageRequest {
    pub message: String,
    pub compact: bool,
}

#[frb(mirror(SignMessageResponse))]
pub struct _SignMessageResponse {
    pub pubkey: String,
    pub signature: String,
}

#[frb(mirror(SuccessAction))]
pub enum _SuccessAction {
    Aes { data: AesSuccessActionData },
    Message { data: MessageSuccessActionData },
    Url { data: UrlSuccessActionData },
}

#[frb(mirror(SuccessActionProcessed))]
pub enum _SuccessActionProcessed {
    Aes { result: AesSuccessActionDataResult },
    Message { data: MessageSuccessActionData },
    Url { data: UrlSuccessActionData },
}

#[frb(mirror(SyncWalletRequest))]
pub struct _SyncWalletRequest {}

#[frb(mirror(SyncWalletResponse))]
pub struct _SyncWalletResponse {}

#[frb(mirror(AesSuccessActionData))]
pub struct _AesSuccessActionData {
    pub description: String,
    pub ciphertext: String,
    pub iv: String,
}

#[frb(mirror(AesSuccessActionDataResult))]
pub enum _AesSuccessActionDataResult {
    Decrypted { data: AesSuccessActionDataDecrypted },
    ErrorStatus { reason: String },
}

#[frb(mirror(AesSuccessActionDataDecrypted))]
pub struct _AesSuccessActionDataDecrypted {
    pub description: String,
    pub plaintext: String,
}

#[frb(mirror(MessageSuccessActionData))]
pub struct _MessageSuccessActionData {
    pub message: String,
}

#[frb(mirror(UrlSuccessActionData))]
pub struct _UrlSuccessActionData {
    pub description: String,
    pub url: String,
    pub matches_callback_domain: bool,
}

#[frb(mirror(Network))]
pub enum _Network {
    Mainnet,
    Regtest,
}

/// Flutter-side counterpart of
/// [`breez_sdk_spark::SdkContextConfig`](breez_sdk_spark::SdkContextConfig).
///
/// Not a mirror: the upstream type carries an `Arc<dyn StorageBackend>` that
/// the Flutter bridge doesn't bridge today. Storage is configured per-SDK via
/// [`SdkBuilder::with_default_storage`](crate::sdk_builder::SdkBuilder::with_default_storage)
/// instead.
pub struct SdkContextConfig {
    pub network: Network,
    pub api_key: Option<String>,
    pub connections_per_operator: Option<u32>,
}

#[frb(mirror(Payment))]
pub struct _Payment {
    pub id: String,
    pub payment_type: PaymentType,
    pub status: PaymentStatus,
    pub amount: u128,
    pub fees: u128,
    pub timestamp: u64,
    pub method: PaymentMethod,
    pub details: Option<PaymentDetails>,
    pub conversion_details: Option<ConversionDetails>,
}

#[frb(mirror(ConversionDetails))]
pub struct _ConversionDetails {
    pub status: ConversionStatus,
    pub conversions: Vec<Conversion>,
}

#[frb(mirror(ConversionProvider))]
pub enum _ConversionProvider {
    Amm,
    Orchestra,
    Boltz,
}

#[frb(mirror(ConversionChain))]
pub enum _ConversionChain {
    Spark,
    Lightning,
    External {
        name: String,
        chain_id: Option<String>,
    },
}

#[frb(mirror(ConversionAsset))]
pub struct _ConversionAsset {
    pub ticker: String,
    pub identifier: Option<String>,
    pub decimals: u32,
}

#[frb(mirror(ConversionSide))]
pub struct _ConversionSide {
    pub chain: ConversionChain,
    pub asset: ConversionAsset,
    pub amount: u128,
    pub fee: u128,
}

#[frb(mirror(Conversion))]
pub struct _Conversion {
    pub provider: ConversionProvider,
    pub status: ConversionStatus,
    pub from: ConversionSide,
    pub to: ConversionSide,
    pub amount_adjustment: Option<AmountAdjustmentReason>,
}

#[frb(mirror(AmountAdjustmentReason))]
pub enum _AmountAdjustmentReason {
    FlooredToMinLimit,
    IncreasedToAvoidDust,
}

#[frb(mirror(SwapDegradation))]
pub enum _SwapDegradation {
    BelowMinimum,
    UnexpectedAsset,
    MissingInfo,
}

#[frb(mirror(PaymentDetails))]
pub enum _PaymentDetails {
    Spark {
        invoice_details: Option<SparkInvoicePaymentDetails>,
        htlc_details: Option<SparkHtlcDetails>,
        conversion_info: Option<ConversionInfo>,
    },
    Token {
        metadata: TokenMetadata,
        tx_hash: String,
        tx_type: TokenTransactionType,
        invoice_details: Option<SparkInvoicePaymentDetails>,
        conversion_info: Option<ConversionInfo>,
    },
    Lightning {
        description: Option<String>,
        invoice: String,
        destination_pubkey: String,
        htlc_details: SparkHtlcDetails,
        lnurl_pay_info: Option<LnurlPayInfo>,
        lnurl_withdraw_info: Option<LnurlWithdrawInfo>,
        lnurl_receive_metadata: Option<LnurlReceiveMetadata>,
        conversion_info: Option<ConversionInfo>,
    },
    Withdraw {
        tx_id: String,
    },
    Deposit {
        tx_id: String,
        vout: u32,
    },
}

#[frb(mirror(TokenTransactionType))]
pub enum _TokenTransactionType {
    Transfer,
    Mint,
    Burn,
}

#[frb(mirror(SparkInvoicePaymentDetails))]
pub struct _SparkInvoicePaymentDetails {
    pub description: Option<String>,
    pub invoice: String,
}

#[frb(mirror(SparkHtlcDetails))]
pub struct _SparkHtlcDetails {
    pub payment_hash: String,
    pub preimage: Option<String>,
    pub expiry_time: u64,
    pub status: SparkHtlcStatus,
}

#[frb(mirror(SparkHtlcStatus))]
pub enum _SparkHtlcStatus {
    WaitingForPreimage,
    PreimageShared,
    Returned,
}

#[frb(mirror(PaymentMetadata))]
pub struct _PaymentMetadata {
    pub lnurl_pay_info: Option<LnurlPayInfo>,
    pub lnurl_withdraw_info: Option<LnurlWithdrawInfo>,
    pub lnurl_description: Option<String>,
    pub conversion_info: Option<ConversionInfo>,
}

#[frb(mirror(PaymentMethod))]
pub enum _PaymentMethod {
    Lightning,
    Spark,
    Token,
    Deposit,
    Withdraw,
    Unknown,
}

#[frb(mirror(PaymentRequestSource))]
pub struct _PaymentRequestSource {
    pub bip_21_uri: Option<String>,
    pub bip_353_address: Option<String>,
}

#[frb(mirror(PaymentStatus))]
pub enum _PaymentStatus {
    Completed,
    Pending,
    Failed,
}

#[frb(mirror(PaymentType))]
pub enum _PaymentType {
    Send,
    Receive,
}

#[frb(mirror(UpdateDepositPayload))]
pub enum _UpdateDepositPayload {
    ClaimError {
        error: DepositClaimError,
    },
    Refund {
        refund_txid: String,
        refund_tx: String,
    },
    InstantClaim {
        status: InstantClaimStatus,
    },
}

#[frb(mirror(Amount))]
pub enum _Amount {
    Bitcoin {
        amount_msat: u64,
    },
    Currency {
        iso4217_code: String,
        fractional_amount: u64,
    },
}

#[frb(mirror(Bip21Details))]
pub struct _Bip21Details {
    pub amount_sat: Option<u64>,
    pub asset_id: Option<String>,
    pub uri: String,
    pub extras: Vec<Bip21Extra>,
    pub label: Option<String>,
    pub message: Option<String>,
    pub payment_methods: Vec<InputType>,
}

#[frb(mirror(Bip21Extra))]
pub struct _Bip21Extra {
    pub key: String,
    pub value: String,
}

#[frb(mirror(Bolt11Invoice))]
pub struct _Bolt11Invoice {
    pub bolt11: String,
    pub source: PaymentRequestSource,
}

#[frb(mirror(Bolt11RouteHint))]
pub struct _Bolt11RouteHint {
    pub hops: Vec<Bolt11RouteHintHop>,
}

#[frb(mirror(Bolt11RouteHintHop))]
pub struct _Bolt11RouteHintHop {
    pub src_node_id: String,
    pub short_channel_id: String,
    pub fees_base_msat: u32,
    pub fees_proportional_millionths: u32,
    pub cltv_expiry_delta: u16,
    pub htlc_minimum_msat: Option<u64>,
    pub htlc_maximum_msat: Option<u64>,
}

#[frb(mirror(Bolt12Invoice))]
pub struct _Bolt12Invoice {
    pub invoice: String,
    pub source: PaymentRequestSource,
}

#[frb(mirror(Bolt12InvoiceRequestDetails))]
pub struct _Bolt12InvoiceRequestDetails {
    // TODO: Fill fields
}

#[frb(mirror(Bolt12OfferBlindedPath))]
pub struct _Bolt12OfferBlindedPath {
    pub blinded_hops: Vec<String>,
}

#[frb(mirror(Bolt11InvoiceDetails))]
pub struct _Bolt11InvoiceDetails {
    pub amount_msat: Option<u64>,
    pub description: Option<String>,
    pub description_hash: Option<String>,
    pub expiry: u64,
    pub invoice: Bolt11Invoice,
    pub min_final_cltv_expiry_delta: u64,
    pub network: BitcoinNetwork,
    pub payee_pubkey: String,
    pub payment_hash: String,
    pub payment_secret: String,
    pub routing_hints: Vec<Bolt11RouteHint>,
    pub timestamp: u64,
}

#[frb(mirror(Bolt12InvoiceDetails))]
pub struct _Bolt12InvoiceDetails {
    pub amount_msat: u64,
    pub invoice: Bolt12Invoice,
}

#[frb(mirror(Bolt12Offer))]
pub struct _Bolt12Offer {
    pub offer: String,
    pub source: PaymentRequestSource,
}

#[frb(mirror(Bolt12OfferDetails))]
pub struct _Bolt12OfferDetails {
    pub absolute_expiry: Option<u64>,
    pub chains: Vec<String>,
    pub description: Option<String>,
    pub issuer: Option<String>,
    pub min_amount: Option<Amount>,
    pub offer: Bolt12Offer,
    pub paths: Vec<Bolt12OfferBlindedPath>,
    pub signing_pubkey: Option<String>,
}

#[frb(mirror(SparkAddressDetails))]
pub struct _SparkAddressDetails {
    pub address: String,
    pub identity_public_key: String,
    pub network: BitcoinNetwork,
    pub source: PaymentRequestSource,
}

#[frb(mirror(SparkInvoiceDetails))]
pub struct _SparkInvoiceDetails {
    pub invoice: String,
    pub identity_public_key: String,
    pub network: BitcoinNetwork,
    pub amount: Option<u128>,
    pub token_identifier: Option<String>,
    pub expiry_time: Option<u64>,
    pub description: Option<String>,
    pub sender_public_key: Option<String>,
}

#[frb(mirror(SparkInvoicePaymentType))]
pub enum _SparkInvoicePaymentType {
    Sats,
    Tokens { token_identifier: Option<String> },
}

#[frb(mirror(LightningAddressDetails))]
pub struct _LightningAddressDetails {
    pub address: String,
    pub pay_request: LnurlPayRequestDetails,
}

#[frb(mirror(LnurlAuthRequestDetails))]
pub struct _LnurlAuthRequestDetails {
    pub k1: String,
    pub action: Option<String>,
    pub domain: String,
    pub url: String,
}

#[frb(mirror(LnurlPayRequestDetails))]
pub struct _LnurlPayRequestDetails {
    pub callback: String,
    pub min_sendable: u64,
    pub max_sendable: u64,
    pub metadata_str: String,
    pub comment_allowed: u16,
    pub domain: String,
    pub url: String,
    pub address: Option<String>,
    pub allows_nostr: Option<bool>,
    pub nostr_pubkey: Option<String>,
}

#[frb(mirror(LnurlWithdrawRequestDetails))]
pub struct _LnurlWithdrawRequestDetails {
    pub callback: String,
    pub k1: String,
    pub default_description: String,
    pub min_withdrawable: u64,
    pub max_withdrawable: u64,
}

#[frb(mirror(SilentPaymentAddressDetails))]
pub struct _SilentPaymentAddressDetails {
    pub address: String,
    pub network: BitcoinNetwork,
    pub source: PaymentRequestSource,
}

#[frb(mirror(CheckLightningAddressRequest))]
pub struct _CheckLightningAddressRequest {
    pub username: String,
}

#[frb(mirror(RegisterLightningAddressRequest))]
pub struct _RegisterLightningAddressRequest {
    pub username: String,
    pub description: Option<String>,
}

#[frb(mirror(TransferAuthorization))]
pub struct _TransferAuthorization {
    pub username: String,
    pub pubkey: String,
    pub signature: String,
    pub domain: String,
    pub timestamp: u64,
}

#[frb(mirror(AuthorizeTransferRequest))]
pub struct _AuthorizeTransferRequest {
    pub transferee_pubkey: String,
}

#[frb(mirror(ClaimTransferRequest))]
pub struct _ClaimTransferRequest {
    pub authorization: TransferAuthorization,
    pub description: Option<String>,
}

#[frb(mirror(LnurlInfo))]
pub struct _LnurlInfo {
    pub url: String,
    pub bech32: String,
}

#[frb(mirror(LightningAddressInfo))]
pub struct _LightningAddressInfo {
    pub description: String,
    pub lightning_address: String,
    pub lnurl: LnurlInfo,
    pub username: String,
}

#[frb(mirror(ListFiatCurrenciesResponse))]
pub struct _ListFiatCurrenciesResponse {
    pub currencies: Vec<FiatCurrency>,
}

#[frb(mirror(ListFiatRatesResponse))]
pub struct _ListFiatRatesResponse {
    pub rates: Vec<Rate>,
}

#[frb(mirror(Rate))]
pub struct _Rate {
    pub coin: String,
    pub value: f64,
}

#[frb(mirror(FiatCurrency))]
pub struct _FiatCurrency {
    pub id: String,
    pub info: CurrencyInfo,
}

#[frb(mirror(CurrencyInfo))]
pub struct _CurrencyInfo {
    pub name: String,
    pub fraction_size: u32,
    pub spacing: Option<u32>,
    pub symbol: Option<Symbol>,
    pub uniq_symbol: Option<Symbol>,
    pub localized_name: Vec<LocalizedName>,
    pub locale_overrides: Vec<LocaleOverrides>,
}

#[frb(mirror(LocaleOverrides))]
pub struct _LocaleOverrides {
    pub locale: String,
    pub spacing: Option<u32>,
    pub symbol: Symbol,
}

#[frb(mirror(LocalizedName))]
pub struct _LocalizedName {
    pub locale: String,
    pub name: String,
}

#[frb(mirror(Symbol))]
pub struct _Symbol {
    pub grapheme: Option<String>,
    pub template: Option<String>,
    pub rtl: Option<bool>,
    pub position: Option<u32>,
}

#[frb(mirror(GetTokensMetadataRequest))]
pub struct _GetTokensMetadataRequest {
    pub token_identifiers: Vec<String>,
}

#[frb(mirror(GetTokensMetadataResponse))]
pub struct _GetTokensMetadataResponse {
    pub tokens_metadata: Vec<TokenMetadata>,
}

#[frb(mirror(RecordId))]
pub struct _RecordId {
    pub r#type: String,
    pub data_id: String,
}

#[frb(mirror(Record))]
pub struct _Record {
    pub id: RecordId,
    pub revision: u64,
    pub schema_version: String,
    pub data: HashMap<String, String>,
}

#[frb(mirror(IncomingChange))]
pub struct _IncomingChange {
    pub new_state: breez_sdk_spark::sync_storage::Record,
    pub old_state: Option<breez_sdk_spark::sync_storage::Record>,
    // pub pending_outgoing_changes: Vec<RecordChange>,
}

#[frb(mirror(OutgoingChange))]
pub struct _OutgoingChange {
    pub change: breez_sdk_spark::sync_storage::RecordChange,
    pub parent: Option<breez_sdk_spark::sync_storage::Record>,
}

#[frb(mirror(UnversionedRecordChange))]
pub struct _UnversionedRecordChange {
    pub id: RecordId,
    pub schema_version: String,
    pub updated_fields: HashMap<String, String>,
}

#[frb(mirror(RecordChange))]
pub struct _RecordChange {
    pub id: RecordId,
    pub schema_version: String,
    pub updated_fields: HashMap<String, String>,
    pub revision: u64,
}

#[frb(mirror(UserSettings))]
pub struct _UserSettings {
    pub spark_private_mode_enabled: bool,
    pub stable_balance_active_label: Option<String>,
    pub spark_master_identity_public_key: Option<String>,
}

#[frb(mirror(StableBalanceActiveLabel))]
pub enum _StableBalanceActiveLabel {
    Set { label: String },
    Unset,
}

#[frb(mirror(SparkMasterIdentityPublicKey))]
pub enum _SparkMasterIdentityPublicKey {
    Set { public_key: String },
    Unset,
}

#[frb(mirror(UpdateUserSettingsRequest))]
pub struct _UpdateUserSettingsRequest {
    pub spark_private_mode_enabled: Option<bool>,
    pub stable_balance_active_label: Option<StableBalanceActiveLabel>,
    pub spark_master_identity_public_key: Option<SparkMasterIdentityPublicKey>,
}

#[frb(mirror(CreateIssuerTokenRequest))]
pub struct _CreateIssuerTokenRequest {
    pub name: String,
    pub ticker: String,
    pub decimals: u32,
    pub is_freezable: bool,
    pub max_supply: u128,
}

#[frb(mirror(MintIssuerTokenRequest))]
pub struct _MintIssuerTokenRequest {
    pub amount: u128,
}

#[frb(mirror(BurnIssuerTokenRequest))]
pub struct _BurnIssuerTokenRequest {
    pub amount: u128,
}

#[frb(mirror(FreezeIssuerTokenRequest))]
pub struct _FreezeIssuerTokenRequest {
    pub address: String,
}

#[frb(mirror(FreezeIssuerTokenResponse))]
pub struct _FreezeIssuerTokenResponse {
    pub impacted_output_ids: Vec<String>,
    pub impacted_token_amount: u128,
}

#[frb(mirror(UnfreezeIssuerTokenRequest))]
pub struct _UnfreezeIssuerTokenRequest {
    pub address: String,
}

#[frb(mirror(UnfreezeIssuerTokenResponse))]
pub struct _UnfreezeIssuerTokenResponse {
    pub impacted_output_ids: Vec<String>,
    pub impacted_token_amount: u128,
}

#[frb(mirror(RecommendedFees))]
pub struct _RecommendedFees {
    pub fastest_fee: u64,
    pub half_hour_fee: u64,
    pub hour_fee: u64,
    pub economy_fee: u64,
    pub minimum_fee: u64,
}

#[frb(mirror(ChainApiType))]
pub enum _ChainApiType {
    Esplora,
    MempoolSpace,
}

#[frb(mirror(ClaimHtlcPaymentRequest))]
pub struct _ClaimHtlcPaymentRequest {
    pub preimage: String,
}

#[frb(mirror(ClaimHtlcPaymentResponse))]
pub struct _ClaimHtlcPaymentResponse {
    pub payment: Payment,
}

#[frb(mirror(OptimizationMode))]
pub enum _OptimizationMode {
    Full,
    SingleRound,
}

#[frb(mirror(OptimizeLeavesRequest))]
pub struct _OptimizeLeavesRequest {
    pub mode: OptimizationMode,
}

#[frb(mirror(OptimizationOutcome))]
pub enum _OptimizationOutcome {
    Completed { rounds_executed: u32 },
    InProgress,
}

#[frb(mirror(OptimizeLeavesResponse))]
pub struct _OptimizeLeavesResponse {
    pub outcome: OptimizationOutcome,
}

#[frb(mirror(ConversionEstimate))]
pub struct _ConversionEstimate {
    pub options: ConversionOptions,
    pub amount_in: u128,
    pub amount_out: u128,
    pub fee: u128,
    pub amount_adjustment: Option<AmountAdjustmentReason>,
}

#[frb(mirror(ConversionPurpose))]
pub enum _ConversionPurpose {
    OngoingPayment { payment_request: String },
    SelfTransfer,
    AutoConversion,
}

#[frb(mirror(ConversionStatus))]
pub enum _ConversionStatus {
    Pending,
    Completed,
    Failed,
    RefundNeeded,
    Refunded,
}

#[frb(mirror(ConversionInfo))]
pub enum _ConversionInfo {
    Amm {
        pool_id: String,
        conversion_id: String,
        status: ConversionStatus,
        fee: Option<u128>,
        purpose: Option<ConversionPurpose>,
        amount_adjustment: Option<AmountAdjustmentReason>,
        degradation: Option<SwapDegradation>,
    },
    Boltz {
        chain: String,
        chain_id: Option<String>,
        asset: String,
        asset_contract: Option<String>,
        recipient_address: String,
        asset_amount_in: Option<u128>,
        estimated_out: u128,
        delivered_amount: Option<u128>,
        status: ConversionStatus,
        fee_amount: Option<u128>,
        service_fee_amount: Option<u128>,
        service_fee_asset: Option<String>,
        asset_decimals: u32,
        swap_id: String,
        invoice: String,
        invoice_amount_sats: u64,
        bridge_ref: Option<String>,
        max_slippage_bps: u32,
        quote_degraded: bool,
    },
    Orchestra {
        chain: String,
        chain_id: Option<String>,
        asset: String,
        asset_contract: Option<String>,
        recipient_address: String,
        asset_amount_in: Option<u128>,
        estimated_out: u128,
        delivered_amount: Option<u128>,
        status: ConversionStatus,
        fee_amount: Option<u128>,
        service_fee_amount: Option<u128>,
        service_fee_asset: Option<String>,
        asset_decimals: u32,
        order_id: String,
        quote_id: String,
        read_token: Option<String>,
    },
}

#[frb(mirror(ConversionOptions))]
pub struct _ConversionOptions {
    pub conversion_type: ConversionType,
    pub max_slippage_bps: Option<u32>,
    pub completion_timeout_secs: Option<u32>,
}

#[frb(mirror(ConversionType))]
pub enum _ConversionType {
    FromBitcoin,
    ToBitcoin { from_token_identifier: String },
}

#[frb(mirror(FetchConversionLimitsRequest))]
pub struct _FetchConversionLimitsRequest {
    pub conversion_type: ConversionType,
    pub token_identifier: Option<String>,
}

#[frb(mirror(FetchConversionLimitsResponse))]
pub struct _FetchConversionLimitsResponse {
    pub min_from_amount: Option<u128>,
    pub min_to_amount: Option<u128>,
}

#[frb(mirror(BuyBitcoinRequest))]
pub enum _BuyBitcoinRequest {
    Moonpay {
        locked_amount_sat: Option<u64>,
        redirect_url: Option<String>,
    },
    CashApp {
        amount_sats: u64,
    },
}

#[frb(mirror(BuyBitcoinResponse))]
pub struct _BuyBitcoinResponse {
    pub url: String,
}

#[frb(mirror(RefundPendingConversionsResponse))]
pub struct _RefundPendingConversionsResponse {
    pub refunded: u32,
    pub skipped: u32,
    pub failed: u32,
}

#[frb(mirror(PreparePaymentLinkRequest))]
pub struct _PreparePaymentLinkRequest {
    pub address: String,
    pub route: CrossChainRoutePair,
    pub amount: u128,
    pub fee_policy: Option<FeePolicy>,
    pub max_slippage_bps: Option<u32>,
}

#[frb(mirror(PreparePaymentLinkResponse))]
pub struct _PreparePaymentLinkResponse {
    pub url: String,
    pub amount_sats: u64,
    pub estimated_out: u128,
    pub asset: String,
    pub service_fee_amount: u128,
    pub service_fee_asset: Option<String>,
    pub expires_at: String,
}

#[frb(mirror(ServiceStatus))]
pub enum _ServiceStatus {
    Operational,
    Degraded,
    Partial,
    Unknown,
    Major,
}

#[frb(mirror(SparkStatus))]
pub struct _SparkStatus {
    pub status: ServiceStatus,
    pub last_updated: u64,
}

#[frb(mirror(Contact))]
pub struct _Contact {
    pub id: String,
    pub name: String,
    pub payment_identifier: String,
    pub created_at: u64,
    pub updated_at: u64,
}

#[frb(mirror(AddContactRequest))]
pub struct _AddContactRequest {
    pub name: String,
    pub payment_identifier: String,
}

#[frb(mirror(UpdateContactRequest))]
pub struct _UpdateContactRequest {
    pub id: String,
    pub name: String,
    pub payment_identifier: String,
}

#[frb(mirror(ListContactsRequest))]
pub struct _ListContactsRequest {
    pub offset: Option<u32>,
    pub limit: Option<u32>,
}

#[frb(mirror(WebhookEventType))]
pub enum _WebhookEventType {
    LightningReceiveFinished,
    LightningSendFinished,
    CoopExitFinished,
    StaticDepositFinished,
    Unknown(String),
}

#[frb(mirror(Webhook))]
pub struct _Webhook {
    pub id: String,
    pub url: String,
    pub event_types: Vec<WebhookEventType>,
}

#[frb(mirror(RegisterWebhookRequest))]
pub struct _RegisterWebhookRequest {
    pub url: String,
    pub secret: String,
    pub event_types: Vec<WebhookEventType>,
}

#[frb(mirror(RegisterWebhookResponse))]
pub struct _RegisterWebhookResponse {
    pub webhook_id: String,
}

#[frb(mirror(UnregisterWebhookRequest))]
pub struct _UnregisterWebhookRequest {
    pub webhook_id: String,
}

#[frb(mirror(PasskeyProviderOptions))]
pub struct _PasskeyProviderOptions {
    pub rp_id: Option<String>,
    pub rp_name: Option<String>,
    pub user_name: Option<String>,
    pub user_display_name: Option<String>,
}

#[frb(mirror(PasskeyConfig))]
pub struct _PasskeyConfig {
    pub default_label: Option<String>,
    pub provider_options: Option<PasskeyProviderOptions>,
}

#[frb(mirror(PasskeyAvailability))]
pub enum _PasskeyAvailability {
    Available,
    PrfUnsupported,
    NotAssociated { source: String, reason: String },
    Skipped { reason: String },
}

#[frb(mirror(Wallet))]
pub struct _Wallet {
    pub seed: Seed,
    pub label: String,
}

#[frb(mirror(PasskeyCredential))]
pub struct _PasskeyCredential {
    pub credential_id: Vec<u8>,
    pub user_id: Option<Vec<u8>>,
    pub aaguid: Option<Vec<u8>>,
    pub backup_eligible: Option<bool>,
}

#[frb(mirror(CreatePasskeyOutput))]
pub struct _CreatePasskeyOutput {
    pub credential: PasskeyCredential,
    pub seeds: Option<Vec<Vec<u8>>>,
}

#[frb(mirror(RegisterRequest))]
pub struct _RegisterRequest {
    pub label: Option<String>,
    pub exclude_credentials: Option<Vec<Vec<u8>>>,
}

#[frb(mirror(RegisterResponse))]
pub struct _RegisterResponse {
    pub wallet: Wallet,
    pub credential: Option<PasskeyCredential>,
}

#[frb(mirror(SignInRequest))]
pub struct _SignInRequest {
    pub label: Option<String>,
    pub allow_credentials: Option<Vec<Vec<u8>>>,
    pub prefer_immediately_available_credentials: Option<bool>,
}

#[frb(mirror(DeriveSeedsRequest))]
pub struct _DeriveSeedsRequest {
    pub salts: Vec<String>,
    pub allow_credentials: Vec<Vec<u8>>,
    pub prefer_immediately_available_credentials: Option<bool>,
}

#[frb(mirror(DeriveSeedsOutput))]
pub struct _DeriveSeedsOutput {
    pub seeds: Vec<Vec<u8>>,
    pub credential_id: Option<Vec<u8>>,
}

#[frb(mirror(SignInResponse))]
pub struct _SignInResponse {
    pub wallet: Wallet,
    pub labels: Vec<String>,
    pub credential: Option<PasskeyCredential>,
}

#[frb(mirror(ConnectWithPasskeyRequest))]
pub struct _ConnectWithPasskeyRequest {
    pub label: Option<String>,
    pub allow_credentials: Option<Vec<Vec<u8>>>,
    pub exclude_credentials: Option<Vec<Vec<u8>>>,
}

#[frb(mirror(ConnectWithPasskeyResponse))]
pub struct _ConnectWithPasskeyResponse {
    pub wallet: Wallet,
    pub credential: Option<PasskeyCredential>,
    pub labels: Vec<String>,
}