@secondts/bark-react-native 0.1.0-beta.6

package/lib/typescript/module/src/generated/bark.d.ts

@@ -0,0 +1,2963 @@
+import { type UniffiByteArray, type UniffiRustArcPtr, type UnsafeMutableRawPointer, FfiConverterObject, RustBuffer, UniffiAbstractObject, destructorGuardSymbol, pointerLiteralSymbol, uniffiTypeNameSymbol } from "uniffi-bindgen-react-native";
+export declare function extractTxFromPsbt(psbtBase64: string): string;
+export declare function generateMnemonic(): string;
+export declare function validateArkAddress(address: string): boolean;
+export declare function validateMnemonic(mnemonic: string): boolean;
+/**
+ * Callback interface for custom onchain wallet implementations
+ *
+ * Implement this interface in Dart/Swift/Kotlin to provide your own wallet.
+ */
+export interface CustomOnchainWalletCallbacks {
+    /**
+     * Get the wallet balance in satoshis
+     */
+    getBalance(): bigint;
+    /**
+     * Prepare a transaction to send to given destinations
+     *
+     * # Arguments
+     * * `destinations` - List of destinations with addresses and amounts
+     * * `fee_rate_sat_per_vb` - Fee rate in sats per vbyte
+     *
+     * # Returns
+     * Base64-encoded PSBT
+     */
+    prepareTx(destinations: Array<Destination>, feeRateSatPerVb: bigint): string;
+    /**
+     * Prepare a transaction that drains the wallet to a single address
+     *
+     * # Arguments
+     * * `address` - Bitcoin address to drain to
+     * * `fee_rate_sat_per_vb` - Fee rate in sats per vbyte
+     *
+     * # Returns
+     * Base64-encoded PSBT
+     */
+    prepareDrainTx(address: string, feeRateSatPerVb: bigint): string;
+    /**
+     * Sign and finalize a PSBT
+     *
+     * # Arguments
+     * * `psbt_base64` - Base64-encoded PSBT
+     *
+     * # Returns
+     * Hex-encoded signed transaction
+     */
+    finishTx(psbtBase64: string): string;
+    /**
+     * Get a wallet transaction by txid
+     *
+     * # Arguments
+     * * `txid` - Transaction ID as hex string
+     *
+     * # Returns
+     * Hex-encoded transaction, or null if not found
+     */
+    getWalletTx(txid: string): /*throws*/ string | undefined;
+    /**
+     * Get the block hash where a transaction was confirmed
+     *
+     * # Arguments
+     * * `txid` - Transaction ID as hex string
+     *
+     * # Returns
+     * Block reference with height and hash, or null if unconfirmed
+     */
+    getWalletTxConfirmedBlock(txid: string): /*throws*/ BlockRef | undefined;
+    /**
+     * Find transaction that spends a given output
+     *
+     * # Arguments
+     * * `outpoint` - Transaction outpoint to check
+     *
+     * # Returns
+     * Hex-encoded spending transaction, or null if unspent
+     */
+    getSpendingTx(outpoint: OutPoint): /*throws*/ string | undefined;
+    /**
+     * Create a signed P2A CPFP transaction
+     *
+     * # Arguments
+     * * `params` - CPFP transaction parameters
+     *
+     * # Returns
+     * Hex-encoded signed CPFP transaction
+     */
+    makeSignedP2aCpfp(params: CpfpParams): string;
+    /**
+     * Store a signed P2A CPFP transaction in the wallet
+     *
+     * # Arguments
+     * * `tx_hex` - Hex-encoded transaction
+     */
+    storeSignedP2aCpfp(txHex: string): void;
+}
+/**
+ * An Ark address with its derivation index
+ */
+export type AddressWithIndex = {
+    /**
+     * The Ark address string
+     */
+    address: string;
+    /**
+     * The derivation index
+     */
+    index: number;
+};
+/**
+ * Generated factory for {@link AddressWithIndex} record objects.
+ */
+export declare const AddressWithIndex: Readonly<{
+    /**
+     * Create a frozen instance of {@link AddressWithIndex}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create: (partial: Partial<AddressWithIndex> & Required<Omit<AddressWithIndex, never>>) => AddressWithIndex;
+    /**
+     * Create a frozen instance of {@link AddressWithIndex}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: (partial: Partial<AddressWithIndex> & Required<Omit<AddressWithIndex, never>>) => AddressWithIndex;
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Partial<AddressWithIndex>;
+}>;
+/**
+ * Ark server configuration information
+ */
+export type ArkInfo = {
+    /**
+     * The bitcoin network the server operates on
+     */
+    network: Network;
+    /**
+     * The Ark server pubkey as hex string
+     */
+    serverPubkey: string;
+    /**
+     * The interval between each round in seconds
+     */
+    roundIntervalSecs: bigint;
+    /**
+     * Number of nonces per round
+     */
+    nbRoundNonces: number;
+    /**
+     * Delta between exit confirmation and coins becoming spendable
+     */
+    vtxoExitDelta: number;
+    /**
+     * Expiration delta of the VTXO
+     */
+    vtxoExpiryDelta: number;
+    /**
+     * The number of blocks after which an HTLC-send VTXO expires once granted
+     */
+    htlcSendExpiryDelta: number;
+    /**
+     * The number of blocks to keep between Lightning and Ark HTLCs expiries
+     */
+    htlcExpiryDelta: number;
+    /**
+     * Maximum amount of a VTXO in sats (null if no limit)
+     */
+    maxVtxoAmountSats: /*u64*/ bigint | undefined;
+    /**
+     * The number of confirmations required to register a board vtxo
+     */
+    requiredBoardConfirmations: number;
+    /**
+     * Maximum CLTV delta server will allow clients to request an invoice generation with
+     */
+    maxUserInvoiceCltvDelta: number;
+    /**
+     * Minimum amount for a board the server will cosign in sats
+     */
+    minBoardAmountSats: bigint;
+    /**
+     * Offboard fee rate in sats per vbyte
+     */
+    offboardFeerateSatPerVb: bigint;
+    /**
+     * Whether the Ark server requires anti-DoS measures for lightning receives
+     */
+    lnReceiveAntiDosRequired: boolean;
+};
+/**
+ * Generated factory for {@link ArkInfo} record objects.
+ */
+export declare const ArkInfo: Readonly<{
+    /**
+     * Create a frozen instance of {@link ArkInfo}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create: (partial: Partial<ArkInfo> & Required<Omit<ArkInfo, never>>) => ArkInfo;
+    /**
+     * Create a frozen instance of {@link ArkInfo}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: (partial: Partial<ArkInfo> & Required<Omit<ArkInfo, never>>) => ArkInfo;
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Partial<ArkInfo>;
+}>;
+/**
+ * Detailed balance breakdown of the wallet
+ */
+export type Balance = {
+    /**
+     * Spendable off-chain balance (Ark) in sats
+     */
+    spendableSats: bigint;
+    /**
+     * Coins locked in a round
+     */
+    pendingInRoundSats: bigint;
+    /**
+     * Coins being unilaterally exited
+     */
+    pendingExitSats: bigint;
+    /**
+     * Coins pending as Lightning sends
+     */
+    pendingLightningSendSats: bigint;
+    /**
+     * Claimable pending Lightning receives
+     * Note: Bark only tracks claimable receives, not total pending.
+     * The upstream Balance struct only provides claimable_lightning_receive.
+     */
+    claimableLightningReceiveSats: bigint;
+    /**
+     * Coins pending board confirmations
+     */
+    pendingBoardSats: bigint;
+};
+/**
+ * Generated factory for {@link Balance} record objects.
+ */
+export declare const Balance: Readonly<{
+    /**
+     * Create a frozen instance of {@link Balance}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create: (partial: Partial<Balance> & Required<Omit<Balance, never>>) => Balance;
+    /**
+     * Create a frozen instance of {@link Balance}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: (partial: Partial<Balance> & Required<Omit<Balance, never>>) => Balance;
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Partial<Balance>;
+}>;
+/**
+ * Reference to a block in the blockchain
+ */
+export type BlockRef = {
+    height: number;
+    hash: string;
+};
+/**
+ * Generated factory for {@link BlockRef} record objects.
+ */
+export declare const BlockRef: Readonly<{
+    /**
+     * Create a frozen instance of {@link BlockRef}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create: (partial: Partial<BlockRef> & Required<Omit<BlockRef, never>>) => BlockRef;
+    /**
+     * Create a frozen instance of {@link BlockRef}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: (partial: Partial<BlockRef> & Required<Omit<BlockRef, never>>) => BlockRef;
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Partial<BlockRef>;
+}>;
+/**
+ * Configuration for creating/opening a Bark wallet
+ */
+export type Config = {
+    /**
+     * Ark server address
+     */
+    serverAddress: string;
+    /**
+     * Esplora HTTP REST server address
+     */
+    esploraAddress: string | undefined;
+    /**
+     * Bitcoind RPC server address
+     */
+    bitcoindAddress: string | undefined;
+    /**
+     * Bitcoind RPC cookie file path
+     */
+    bitcoindCookiefile: string | undefined;
+    /**
+     * Bitcoind RPC username
+     */
+    bitcoindUser: string | undefined;
+    /**
+     * Bitcoind RPC password
+     */
+    bitcoindPass: string | undefined;
+    /**
+     * Bitcoin network
+     */
+    network: Network;
+    /**
+     * Number of blocks before expiration to refresh VTXOs
+     */
+    vtxoRefreshExpiryThreshold: /*u32*/ number | undefined;
+    /**
+     * Upper limit of blocks needed to safely exit VTXOs
+     */
+    vtxoExitMargin: /*u16*/ number | undefined;
+    /**
+     * Number of blocks to claim a HTLC-recv VTXO
+     */
+    htlcRecvClaimDelta: /*u16*/ number | undefined;
+    /**
+     * Fallback fee rate in sat/kWu
+     */
+    fallbackFeeRate: /*u64*/ bigint | undefined;
+    /**
+     * Confirmations required before considering a round tx fully confirmed
+     */
+    roundTxRequiredConfirmations: /*u32*/ number | undefined;
+};
+/**
+ * Generated factory for {@link Config} record objects.
+ */
+export declare const Config: Readonly<{
+    /**
+     * Create a frozen instance of {@link Config}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create: (partial: Partial<Config> & Required<Omit<Config, never>>) => Config;
+    /**
+     * Create a frozen instance of {@link Config}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: (partial: Partial<Config> & Required<Omit<Config, never>>) => Config;
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Partial<Config>;
+}>;
+/**
+ * Parameters for creating a CPFP (Child Pays For Parent) transaction
+ */
+export type CpfpParams = {
+    /**
+     * Parent transaction to fee-bump (hex-encoded)
+     */
+    txHex: string;
+    /**
+     * Fee strategy: "Effective" for normal fee, "Rbf" for replace-by-fee
+     */
+    feesType: string;
+    /**
+     * Target effective fee rate in sat/vB
+     */
+    effectiveFeeRateSatPerVb: bigint;
+    /**
+     * Current package fee in sats (only required for RBF)
+     */
+    currentPackageFeeSats: /*u64*/ bigint | undefined;
+};
+/**
+ * Generated factory for {@link CpfpParams} record objects.
+ */
+export declare const CpfpParams: Readonly<{
+    /**
+     * Create a frozen instance of {@link CpfpParams}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create: (partial: Partial<CpfpParams> & Required<Omit<CpfpParams, never>>) => CpfpParams;
+    /**
+     * Create a frozen instance of {@link CpfpParams}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: (partial: Partial<CpfpParams> & Required<Omit<CpfpParams, never>>) => CpfpParams;
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Partial<CpfpParams>;
+}>;
+/**
+ * A Bitcoin transaction output destination
+ */
+export type Destination = {
+    address: string;
+    amountSats: bigint;
+};
+/**
+ * Generated factory for {@link Destination} record objects.
+ */
+export declare const Destination: Readonly<{
+    /**
+     * Create a frozen instance of {@link Destination}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create: (partial: Partial<Destination> & Required<Omit<Destination, never>>) => Destination;
+    /**
+     * Create a frozen instance of {@link Destination}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: (partial: Partial<Destination> & Required<Omit<Destination, never>>) => Destination;
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Partial<Destination>;
+}>;
+/**
+ * Claim transaction for exited funds
+ */
+export type ExitClaimTransaction = {
+    /**
+     * Base64-encoded PSBT
+     */
+    psbtBase64: string;
+    /**
+     * Transaction fee in sats
+     */
+    feeSats: bigint;
+};
+/**
+ * Generated factory for {@link ExitClaimTransaction} record objects.
+ */
+export declare const ExitClaimTransaction: Readonly<{
+    /**
+     * Create a frozen instance of {@link ExitClaimTransaction}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create: (partial: Partial<ExitClaimTransaction> & Required<Omit<ExitClaimTransaction, never>>) => ExitClaimTransaction;
+    /**
+     * Create a frozen instance of {@link ExitClaimTransaction}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: (partial: Partial<ExitClaimTransaction> & Required<Omit<ExitClaimTransaction, never>>) => ExitClaimTransaction;
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Partial<ExitClaimTransaction>;
+}>;
+/**
+ * Status of an exit progression
+ */
+export type ExitProgressStatus = {
+    /**
+     * VTXO ID being exited
+     */
+    vtxoId: string;
+    /**
+     * Current state
+     */
+    state: string;
+    /**
+     * Error if any occurred
+     */
+    error: string | undefined;
+};
+/**
+ * Generated factory for {@link ExitProgressStatus} record objects.
+ */
+export declare const ExitProgressStatus: Readonly<{
+    /**
+     * Create a frozen instance of {@link ExitProgressStatus}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create: (partial: Partial<ExitProgressStatus> & Required<Omit<ExitProgressStatus, never>>) => ExitProgressStatus;
+    /**
+     * Create a frozen instance of {@link ExitProgressStatus}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: (partial: Partial<ExitProgressStatus> & Required<Omit<ExitProgressStatus, never>>) => ExitProgressStatus;
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Partial<ExitProgressStatus>;
+}>;
+/**
+ * Detailed status of an exit transaction
+ */
+export type ExitTransactionStatus = {
+    /**
+     * VTXO ID
+     */
+    vtxoId: string;
+    /**
+     * Current state
+     */
+    state: string;
+    /**
+     * State history (if requested)
+     */
+    history: Array<string> | undefined;
+    /**
+     * Number of transactions
+     */
+    transactionCount: number;
+};
+/**
+ * Generated factory for {@link ExitTransactionStatus} record objects.
+ */
+export declare const ExitTransactionStatus: Readonly<{
+    /**
+     * Create a frozen instance of {@link ExitTransactionStatus}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create: (partial: Partial<ExitTransactionStatus> & Required<Omit<ExitTransactionStatus, never>>) => ExitTransactionStatus;
+    /**
+     * Create a frozen instance of {@link ExitTransactionStatus}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: (partial: Partial<ExitTransactionStatus> & Required<Omit<ExitTransactionStatus, never>>) => ExitTransactionStatus;
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Partial<ExitTransactionStatus>;
+}>;
+/**
+ * A VTXO in the exit process
+ */
+export type ExitVtxo = {
+    /**
+     * VTXO ID
+     */
+    vtxoId: string;
+    /**
+     * Amount in sats
+     */
+    amountSats: bigint;
+    /**
+     * Current exit state
+     */
+    state: string;
+    /**
+     * Whether this exit is claimable
+     */
+    isClaimable: boolean;
+};
+/**
+ * Generated factory for {@link ExitVtxo} record objects.
+ */
+export declare const ExitVtxo: Readonly<{
+    /**
+     * Create a frozen instance of {@link ExitVtxo}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create: (partial: Partial<ExitVtxo> & Required<Omit<ExitVtxo, never>>) => ExitVtxo;
+    /**
+     * Create a frozen instance of {@link ExitVtxo}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: (partial: Partial<ExitVtxo> & Required<Omit<ExitVtxo, never>>) => ExitVtxo;
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Partial<ExitVtxo>;
+}>;
+/**
+ * Result of creating a BOLT11 invoice
+ */
+export type LightningInvoice = {
+    /**
+     * The BOLT11 invoice string
+     */
+    invoice: string;
+    /**
+     * Amount in sats
+     */
+    amountSats: bigint;
+};
+/**
+ * Generated factory for {@link LightningInvoice} record objects.
+ */
+export declare const LightningInvoice: Readonly<{
+    /**
+     * Create a frozen instance of {@link LightningInvoice}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create: (partial: Partial<LightningInvoice> & Required<Omit<LightningInvoice, never>>) => LightningInvoice;
+    /**
+     * Create a frozen instance of {@link LightningInvoice}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: (partial: Partial<LightningInvoice> & Required<Omit<LightningInvoice, never>>) => LightningInvoice;
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Partial<LightningInvoice>;
+}>;
+/**
+ * Status of a pending Lightning receive
+ */
+export type LightningReceive = {
+    /**
+     * Payment hash
+     */
+    paymentHash: string;
+    /**
+     * The BOLT11 invoice
+     */
+    invoice: string;
+    /**
+     * Amount in sats
+     */
+    amountSats: bigint;
+    /**
+     * Whether HTLC VTXOs have been received
+     */
+    hasHtlcVtxos: boolean;
+    /**
+     * Whether preimage has been revealed
+     */
+    preimageRevealed: boolean;
+};
+/**
+ * Generated factory for {@link LightningReceive} record objects.
+ */
+export declare const LightningReceive: Readonly<{
+    /**
+     * Create a frozen instance of {@link LightningReceive}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create: (partial: Partial<LightningReceive> & Required<Omit<LightningReceive, never>>) => LightningReceive;
+    /**
+     * Create a frozen instance of {@link LightningReceive}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: (partial: Partial<LightningReceive> & Required<Omit<LightningReceive, never>>) => LightningReceive;
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Partial<LightningReceive>;
+}>;
+/**
+ * Lightning send payment information
+ */
+export type LightningSend = {
+    /**
+     * The invoice being paid
+     */
+    invoice: string;
+    /**
+     * Amount in sats
+     */
+    amountSats: bigint;
+    /**
+     * Number of HTLC VTXOs locked
+     */
+    htlcVtxoCount: number;
+    /**
+     * Payment preimage (only present if payment completed)
+     */
+    preimage: string | undefined;
+};
+/**
+ * Generated factory for {@link LightningSend} record objects.
+ */
+export declare const LightningSend: Readonly<{
+    /**
+     * Create a frozen instance of {@link LightningSend}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create: (partial: Partial<LightningSend> & Required<Omit<LightningSend, never>>) => LightningSend;
+    /**
+     * Create a frozen instance of {@link LightningSend}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: (partial: Partial<LightningSend> & Required<Omit<LightningSend, never>>) => LightningSend;
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Partial<LightningSend>;
+}>;
+/**
+ * Wallet movement/transaction record
+ */
+export type Movement = {
+    /**
+     * Movement ID
+     */
+    id: number;
+    /**
+     * Status (pending, successful, failed, canceled)
+     */
+    status: string;
+    /**
+     * Subsystem name
+     */
+    subsystemName: string;
+    /**
+     * Subsystem kind
+     */
+    subsystemKind: string;
+    /**
+     * Metadata as JSON string
+     */
+    metadataJson: string;
+    /**
+     * Intended balance change in sats
+     */
+    intendedBalanceSats: bigint;
+    /**
+     * Effective balance change in sats
+     */
+    effectiveBalanceSats: bigint;
+    /**
+     * Offchain fee in sats
+     */
+    offchainFeeSats: bigint;
+    /**
+     * Addresses/invoices sent to
+     */
+    sentToAddresses: Array<string>;
+    /**
+     * Addresses/invoices received on
+     */
+    receivedOnAddresses: Array<string>;
+    /**
+     * Input VTXO IDs
+     */
+    inputVtxoIds: Array<string>;
+    /**
+     * Output VTXO IDs
+     */
+    outputVtxoIds: Array<string>;
+    /**
+     * VTXOs sent to exit system
+     */
+    exitedVtxoIds: Array<string>;
+    /**
+     * Created at timestamp
+     */
+    createdAt: string;
+    /**
+     * Updated at timestamp
+     */
+    updatedAt: string;
+    /**
+     * Completed at timestamp (null if not completed)
+     */
+    completedAt: string | undefined;
+};
+/**
+ * Generated factory for {@link Movement} record objects.
+ */
+export declare const Movement: Readonly<{
+    /**
+     * Create a frozen instance of {@link Movement}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create: (partial: Partial<Movement> & Required<Omit<Movement, never>>) => Movement;
+    /**
+     * Create a frozen instance of {@link Movement}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: (partial: Partial<Movement> & Required<Omit<Movement, never>>) => Movement;
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Partial<Movement>;
+}>;
+/**
+ * Result of an offboard operation
+ */
+export type OffboardResult = {
+    /**
+     * The round ID
+     */
+    roundId: string;
+};
+/**
+ * Generated factory for {@link OffboardResult} record objects.
+ */
+export declare const OffboardResult: Readonly<{
+    /**
+     * Create a frozen instance of {@link OffboardResult}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create: (partial: Partial<OffboardResult> & Required<Omit<OffboardResult, never>>) => OffboardResult;
+    /**
+     * Create a frozen instance of {@link OffboardResult}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: (partial: Partial<OffboardResult> & Required<Omit<OffboardResult, never>>) => OffboardResult;
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Partial<OffboardResult>;
+}>;
+/**
+ * Onchain Bitcoin wallet balance
+ */
+export type OnchainBalance = {
+    /**
+     * Confirmed balance in sats
+     */
+    confirmedSats: bigint;
+    /**
+     * Pending balance (trusted + untrusted) in sats
+     */
+    pendingSats: bigint;
+    /**
+     * Total balance in sats
+     */
+    totalSats: bigint;
+};
+/**
+ * Generated factory for {@link OnchainBalance} record objects.
+ */
+export declare const OnchainBalance: Readonly<{
+    /**
+     * Create a frozen instance of {@link OnchainBalance}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create: (partial: Partial<OnchainBalance> & Required<Omit<OnchainBalance, never>>) => OnchainBalance;
+    /**
+     * Create a frozen instance of {@link OnchainBalance}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: (partial: Partial<OnchainBalance> & Required<Omit<OnchainBalance, never>>) => OnchainBalance;
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Partial<OnchainBalance>;
+}>;
+/**
+ * A Bitcoin transaction outpoint (reference to a previous output)
+ */
+export type OutPoint = {
+    txid: string;
+    vout: number;
+};
+/**
+ * Generated factory for {@link OutPoint} record objects.
+ */
+export declare const OutPoint: Readonly<{
+    /**
+     * Create a frozen instance of {@link OutPoint}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create: (partial: Partial<OutPoint> & Required<Omit<OutPoint, never>>) => OutPoint;
+    /**
+     * Create a frozen instance of {@link OutPoint}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: (partial: Partial<OutPoint> & Required<Omit<OutPoint, never>>) => OutPoint;
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Partial<OutPoint>;
+}>;
+/**
+ * Pending board transaction information
+ */
+export type PendingBoard = {
+    /**
+     * VTXO ID that will be created once board is registered
+     */
+    vtxoId: string;
+    /**
+     * Amount being boarded in sats
+     */
+    amountSats: bigint;
+    /**
+     * On-chain transaction ID
+     */
+    txid: string;
+};
+/**
+ * Generated factory for {@link PendingBoard} record objects.
+ */
+export declare const PendingBoard: Readonly<{
+    /**
+     * Create a frozen instance of {@link PendingBoard}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create: (partial: Partial<PendingBoard> & Required<Omit<PendingBoard, never>>) => PendingBoard;
+    /**
+     * Create a frozen instance of {@link PendingBoard}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: (partial: Partial<PendingBoard> & Required<Omit<PendingBoard, never>>) => PendingBoard;
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Partial<PendingBoard>;
+}>;
+/**
+ * A pending round state
+ */
+export type RoundState = {
+    /**
+     * Round ID
+     */
+    id: number;
+    /**
+     * Whether the round is ongoing
+     */
+    ongoing: boolean;
+};
+/**
+ * Generated factory for {@link RoundState} record objects.
+ */
+export declare const RoundState: Readonly<{
+    /**
+     * Create a frozen instance of {@link RoundState}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create: (partial: Partial<RoundState> & Required<Omit<RoundState, never>>) => RoundState;
+    /**
+     * Create a frozen instance of {@link RoundState}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: (partial: Partial<RoundState> & Required<Omit<RoundState, never>>) => RoundState;
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Partial<RoundState>;
+}>;
+/**
+ * Simplified view of a VTXO
+ */
+export type Vtxo = {
+    /**
+     * VTXO id like "686...9aa:0"
+     */
+    id: string;
+    /**
+     * Amount in sats
+     */
+    amountSats: bigint;
+    /**
+     * Expiry height (0 if unknown)
+     */
+    expiryHeight: number;
+    /**
+     * Type of VTXO (e.g., "board", "round", "arkoor")
+     */
+    kind: string;
+    /**
+     * State of VTXO (e.g., "spendable", "spent", "locked")
+     */
+    state: string;
+};
+/**
+ * Generated factory for {@link Vtxo} record objects.
+ */
+export declare const Vtxo: Readonly<{
+    /**
+     * Create a frozen instance of {@link Vtxo}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create: (partial: Partial<Vtxo> & Required<Omit<Vtxo, never>>) => Vtxo;
+    /**
+     * Create a frozen instance of {@link Vtxo}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: (partial: Partial<Vtxo> & Required<Omit<Vtxo, never>>) => Vtxo;
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Partial<Vtxo>;
+}>;
+/**
+ * Read-only properties of the wallet
+ */
+export type WalletProperties = {
+    network: Network;
+    fingerprint: string;
+};
+/**
+ * Generated factory for {@link WalletProperties} record objects.
+ */
+export declare const WalletProperties: Readonly<{
+    /**
+     * Create a frozen instance of {@link WalletProperties}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create: (partial: Partial<WalletProperties> & Required<Omit<WalletProperties, never>>) => WalletProperties;
+    /**
+     * Create a frozen instance of {@link WalletProperties}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: (partial: Partial<WalletProperties> & Required<Omit<WalletProperties, never>>) => WalletProperties;
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Partial<WalletProperties>;
+}>;
+export declare enum BarkError_Tags {
+    Network = "Network",
+    Database = "Database",
+    InvalidMnemonic = "InvalidMnemonic",
+    InvalidAddress = "InvalidAddress",
+    InvalidInvoice = "InvalidInvoice",
+    InvalidPsbt = "InvalidPsbt",
+    InvalidTransaction = "InvalidTransaction",
+    InsufficientFunds = "InsufficientFunds",
+    NotFound = "NotFound",
+    ServerConnection = "ServerConnection",
+    Internal = "Internal",
+    OnchainWalletRequired = "OnchainWalletRequired"
+}
+/**
+ * Error types that can occur when using the Bark wallet
+ */
+export declare const BarkError: Readonly<{
+    instanceOf: (obj: any) => obj is BarkError;
+    Network: {
+        new (inner: {
+            errorMessage: string;
+        }): {
+            readonly tag: BarkError_Tags.Network;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            errorMessage: string;
+        }): {
+            readonly tag: BarkError_Tags.Network;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: BarkError_Tags.Network;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: BarkError_Tags.Network;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: BarkError_Tags.Network;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            errorMessage: string;
+        }>;
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    Database: {
+        new (inner: {
+            errorMessage: string;
+        }): {
+            readonly tag: BarkError_Tags.Database;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            errorMessage: string;
+        }): {
+            readonly tag: BarkError_Tags.Database;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: BarkError_Tags.Database;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: BarkError_Tags.Database;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: BarkError_Tags.Database;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            errorMessage: string;
+        }>;
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    InvalidMnemonic: {
+        new (inner: {
+            errorMessage: string;
+        }): {
+            readonly tag: BarkError_Tags.InvalidMnemonic;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            errorMessage: string;
+        }): {
+            readonly tag: BarkError_Tags.InvalidMnemonic;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: BarkError_Tags.InvalidMnemonic;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: BarkError_Tags.InvalidMnemonic;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: BarkError_Tags.InvalidMnemonic;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            errorMessage: string;
+        }>;
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    InvalidAddress: {
+        new (inner: {
+            errorMessage: string;
+        }): {
+            readonly tag: BarkError_Tags.InvalidAddress;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            errorMessage: string;
+        }): {
+            readonly tag: BarkError_Tags.InvalidAddress;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: BarkError_Tags.InvalidAddress;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: BarkError_Tags.InvalidAddress;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: BarkError_Tags.InvalidAddress;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            errorMessage: string;
+        }>;
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    InvalidInvoice: {
+        new (inner: {
+            errorMessage: string;
+        }): {
+            readonly tag: BarkError_Tags.InvalidInvoice;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            errorMessage: string;
+        }): {
+            readonly tag: BarkError_Tags.InvalidInvoice;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: BarkError_Tags.InvalidInvoice;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: BarkError_Tags.InvalidInvoice;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: BarkError_Tags.InvalidInvoice;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            errorMessage: string;
+        }>;
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    InvalidPsbt: {
+        new (inner: {
+            errorMessage: string;
+        }): {
+            readonly tag: BarkError_Tags.InvalidPsbt;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            errorMessage: string;
+        }): {
+            readonly tag: BarkError_Tags.InvalidPsbt;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: BarkError_Tags.InvalidPsbt;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: BarkError_Tags.InvalidPsbt;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: BarkError_Tags.InvalidPsbt;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            errorMessage: string;
+        }>;
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    InvalidTransaction: {
+        new (inner: {
+            errorMessage: string;
+        }): {
+            readonly tag: BarkError_Tags.InvalidTransaction;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            errorMessage: string;
+        }): {
+            readonly tag: BarkError_Tags.InvalidTransaction;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: BarkError_Tags.InvalidTransaction;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: BarkError_Tags.InvalidTransaction;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: BarkError_Tags.InvalidTransaction;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            errorMessage: string;
+        }>;
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    InsufficientFunds: {
+        new (inner: {
+            errorMessage: string;
+        }): {
+            readonly tag: BarkError_Tags.InsufficientFunds;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            errorMessage: string;
+        }): {
+            readonly tag: BarkError_Tags.InsufficientFunds;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: BarkError_Tags.InsufficientFunds;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: BarkError_Tags.InsufficientFunds;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: BarkError_Tags.InsufficientFunds;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            errorMessage: string;
+        }>;
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    NotFound: {
+        new (inner: {
+            errorMessage: string;
+        }): {
+            readonly tag: BarkError_Tags.NotFound;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            errorMessage: string;
+        }): {
+            readonly tag: BarkError_Tags.NotFound;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: BarkError_Tags.NotFound;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: BarkError_Tags.NotFound;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: BarkError_Tags.NotFound;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            errorMessage: string;
+        }>;
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    ServerConnection: {
+        new (inner: {
+            errorMessage: string;
+        }): {
+            readonly tag: BarkError_Tags.ServerConnection;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            errorMessage: string;
+        }): {
+            readonly tag: BarkError_Tags.ServerConnection;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: BarkError_Tags.ServerConnection;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: BarkError_Tags.ServerConnection;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: BarkError_Tags.ServerConnection;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            errorMessage: string;
+        }>;
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    Internal: {
+        new (inner: {
+            errorMessage: string;
+        }): {
+            readonly tag: BarkError_Tags.Internal;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            errorMessage: string;
+        }): {
+            readonly tag: BarkError_Tags.Internal;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: BarkError_Tags.Internal;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: BarkError_Tags.Internal;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: BarkError_Tags.Internal;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            errorMessage: string;
+        }>;
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    OnchainWalletRequired: {
+        new (inner: {
+            errorMessage: string;
+        }): {
+            readonly tag: BarkError_Tags.OnchainWalletRequired;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            errorMessage: string;
+        }): {
+            readonly tag: BarkError_Tags.OnchainWalletRequired;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: BarkError_Tags.OnchainWalletRequired;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: BarkError_Tags.OnchainWalletRequired;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: BarkError_Tags.OnchainWalletRequired;
+            readonly inner: Readonly<{
+                errorMessage: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BarkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            errorMessage: string;
+        }>;
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+}>;
+/**
+ * Error types that can occur when using the Bark wallet
+ */
+export type BarkError = InstanceType<(typeof BarkError)[keyof Omit<typeof BarkError, "instanceOf">]>;
+/**
+ * Bitcoin network types
+ */
+export declare enum Network {
+    Bitcoin = 0,
+    Testnet = 1,
+    Signet = 2,
+    Regtest = 3
+}
+/**
+ * Onchain Bitcoin wallet for boarding and exits
+ *
+ * Supports two implementations:
+ * - Default: BDK-based wallet (built-in)
+ * - Custom: Your own wallet implementation via callbacks
+ */
+export interface OnchainWalletInterface {
+    /**
+     * Get the onchain wallet balance
+     */
+    balance(): OnchainBalance;
+    /**
+     * Generate a new Bitcoin address
+     */
+    newAddress(): string;
+    /**
+     * Send Bitcoin to an address
+     * Returns the transaction ID
+     */
+    send(address: string, amountSats: bigint, feeRateSatPerVb: bigint): string;
+    /**
+     * Sync the onchain wallet with the blockchain
+     * Returns the amount synced in satoshis
+     */
+    sync(): bigint;
+}
+/**
+ * Onchain Bitcoin wallet for boarding and exits
+ *
+ * Supports two implementations:
+ * - Default: BDK-based wallet (built-in)
+ * - Custom: Your own wallet implementation via callbacks
+ */
+export declare class OnchainWallet extends UniffiAbstractObject implements OnchainWalletInterface {
+    readonly [uniffiTypeNameSymbol] = "OnchainWallet";
+    readonly [destructorGuardSymbol]: UniffiRustArcPtr;
+    readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
+    private constructor();
+    /**
+     * Create an onchain wallet using a custom implementation
+     *
+     * Use this when you have an existing wallet implementation in your language
+     * (Dart/Swift/Kotlin) and want to integrate it with Bark for boarding and exits.
+     * Your implementation must handle all wallet operations via the callbacks interface.
+     */
+    static custom(callbacks: CustomOnchainWalletCallbacks): OnchainWalletInterface;
+    /**
+     * Create or load an onchain wallet using a default BDK implementation shipped with Bark
+     *
+     * The wallet uses BDK for onchain operations
+     * and the same chain source configuration as the Bark wallet (esplora_address or bitcoind_*).
+     */
+    static default_(mnemonic: string, config: Config, datadir: string): OnchainWalletInterface;
+    /**
+     * Get the onchain wallet balance
+     */
+    balance(): OnchainBalance;
+    /**
+     * Generate a new Bitcoin address
+     */
+    newAddress(): string;
+    /**
+     * Send Bitcoin to an address
+     * Returns the transaction ID
+     */
+    send(address: string, amountSats: bigint, feeRateSatPerVb: bigint): string;
+    /**
+     * Sync the onchain wallet with the blockchain
+     * Returns the amount synced in satoshis
+     */
+    sync(): bigint;
+    /**
+     * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+     */
+    uniffiDestroy(): void;
+    static instanceOf(obj: any): obj is OnchainWallet;
+}
+/**
+ * The main Bark wallet interface for Ark operations
+ */
+export interface WalletInterface {
+    /**
+     * Get earliest block height when all exits will be claimable
+     *
+     * Returns null if no exits or any exit has undetermined claimability.
+     */
+    allExitsClaimableAtHeight(): /*throws*/ /*u32*/ number | undefined;
+    /**
+     * Get all VTXOs (including spent)
+     */
+    allVtxos(): Array<Vtxo>;
+    /**
+     * Get Ark server info (null if not connected)
+     */
+    arkInfo(): ArkInfo | undefined;
+    balance(): Balance;
+    /**
+     * Board all funds from onchain wallet into Ark
+     */
+    boardAll(onchainWallet: OnchainWalletInterface): PendingBoard;
+    /**
+     * Board a specific amount from onchain wallet into Ark
+     */
+    boardAmount(onchainWallet: OnchainWalletInterface, amountSats: bigint): PendingBoard;
+    bolt11Invoice(amountSats: bigint): LightningInvoice;
+    /**
+     * Broadcast a signed transaction to the Bitcoin network
+     *
+     * Takes a hex-encoded transaction and broadcasts it via the wallet's chain source.
+     * This is useful after extracting a transaction from a PSBT using extract_tx_from_psbt.
+     *
+     * # Arguments
+     *
+     * * `tx_hex` - Hex-encoded signed transaction
+     *
+     * Returns the transaction ID (txid) of the broadcasted transaction
+     */
+    broadcastTx(txHex: string): string;
+    /**
+     * Cancel all pending rounds
+     */
+    cancelAllPendingRounds(): void;
+    /**
+     * Cancel a specific pending round
+     */
+    cancelPendingRound(roundId: number): void;
+    /**
+     * Check lightning payment status by payment hash
+     *
+     * # Arguments
+     *
+     * * `payment_hash` - Payment hash as hex string
+     * * `wait` - Whether to wait for the payment to complete
+     *
+     * Returns the preimage if payment is successful, null if still pending
+     */
+    checkLightningPayment(paymentHash: string, wait: boolean): /*throws*/ string | undefined;
+    /**
+     * Get claimable lightning receive balance
+     */
+    claimableLightningReceiveBalanceSats(): bigint;
+    /**
+     * Get wallet config
+     */
+    config(): Config;
+    /**
+     * Drain claimable exits to an address
+     *
+     * Builds a signed PSBT that claims exited funds and sends them to the address.
+     * The PSBT can be broadcast directly or modified before broadcasting.
+     *
+     * # Arguments
+     *
+     * * `vtxo_ids` - List of claimable VTXO IDs to drain (empty = drain all)
+     * * `address` - Bitcoin address to send claimed funds to
+     * * `fee_rate_sat_per_vb` - Optional fee rate override in sats/vB
+     */
+    drainExits(vtxoIds: Array<string>, address: string, feeRateSatPerVb: /*u64*/ bigint | undefined): ExitClaimTransaction;
+    /**
+     * Get detailed exit status for a specific VTXO
+     *
+     * Returns detailed status including current state, history, and transactions.
+     *
+     * # Arguments
+     *
+     * * `vtxo_id` - The VTXO ID to check
+     * * `include_history` - Whether to include full state machine history
+     * * `include_transactions` - Whether to include transaction details
+     */
+    getExitStatus(vtxoId: string, includeHistory: boolean, includeTransactions: boolean): /*throws*/ ExitTransactionStatus | undefined;
+    /**
+     * Get all VTXOs currently in exit process
+     */
+    getExitVtxos(): Array<ExitVtxo>;
+    /**
+     * Get VTXOs expiring within threshold blocks
+     */
+    getExpiringVtxos(thresholdBlocks: number): Array<Vtxo>;
+    /**
+     * Get the block height of the first expiring VTXO
+     *
+     * Returns null if there are no spendable VTXOs.
+     */
+    getFirstExpiringVtxoBlockheight(): /*throws*/ /*u32*/ number | undefined;
+    /**
+     * Get the next block height when a refresh should be performed
+     *
+     * This is calculated as the first expiring VTXO height minus the refresh threshold.
+     * Returns null if there are no VTXOs to refresh.
+     */
+    getNextRequiredRefreshBlockheight(): /*throws*/ /*u32*/ number | undefined;
+    /**
+     * Get a specific VTXO by ID
+     */
+    getVtxoById(vtxoId: string): Vtxo;
+    /**
+     * Get VTXOs that should be refreshed
+     */
+    getVtxosToRefresh(): Array<Vtxo>;
+    /**
+     * Check if any exits are pending
+     */
+    hasPendingExits(): boolean;
+    /**
+     * Get all wallet movements (transaction history)
+     */
+    history(): Array<Movement>;
+    /**
+     * Get lightning receive status by payment hash
+     *
+     * # Arguments
+     *
+     * * `payment_hash` - Payment hash as hex string
+     */
+    lightningReceiveStatus(paymentHash: string): /*throws*/ LightningReceive | undefined;
+    /**
+     * List all exits that are claimable
+     *
+     * Returns exits ready to be drained to onchain wallet.
+     */
+    listClaimableExits(): Array<ExitVtxo>;
+    maintenance(): void;
+    /**
+     * Perform maintenance refresh
+     */
+    maintenanceRefresh(): /*throws*/ string | undefined;
+    /**
+     * Full maintenance including onchain wallet sync
+     *
+     * More thorough than maintenance() - also syncs onchain wallet and exits.
+     */
+    maintenanceWithOnchain(onchainWallet: OnchainWalletInterface): void;
+    /**
+     * Schedule a maintenance refresh if VTXOs need refreshing
+     *
+     * Returns the round ID if a refresh was scheduled, null otherwise.
+     */
+    maybeScheduleMaintenanceRefresh(): /*throws*/ /*u32*/ number | undefined;
+    newAddress(): string;
+    /**
+     * Generate a new address and return it with its index
+     */
+    newAddressWithIndex(): AddressWithIndex;
+    offboardAll(bitcoinAddress: string): OffboardResult;
+    /**
+     * Offboard specific VTXOs to a Bitcoin address
+     */
+    offboardVtxos(vtxoIds: Array<string>, bitcoinAddress: string): string;
+    payLightningAddress(lightningAddress: string, amountSats: bigint, comment: string | undefined): LightningSend;
+    payLightningInvoice(invoice: string, amountSats: /*u64*/ bigint | undefined): LightningSend;
+    /**
+     * Pay a BOLT12 lightning offer
+     *
+     * # Arguments
+     *
+     * * `offer` - BOLT12 offer string
+     * * `amount_sats` - Optional amount in sats (required if offer doesn't specify amount)
+     */
+    payLightningOffer(offer: string, amountSats: /*u64*/ bigint | undefined): LightningSend;
+    /**
+     * Peek at an address at a specific index
+     */
+    peakAddress(index: number): string;
+    /**
+     * Get total amount in pending exits (sats)
+     */
+    pendingExitsTotalSats(): bigint;
+    /**
+     * Get all pending lightning receives
+     */
+    pendingLightningReceives(): Array<LightningReceive>;
+    /**
+     * Get all pending lightning sends
+     */
+    pendingLightningSends(): Array<LightningSend>;
+    /**
+     * Get all pending round states
+     */
+    pendingRoundStates(): Array<RoundState>;
+    /**
+     * Progress unilateral exits (broadcast, fee bump, advance state machine)
+     *
+     * This is the critical method for actually moving exits forward.
+     * Call periodically after starting exits.
+     *
+     * # Arguments
+     *
+     * * `onchain_wallet` - Onchain wallet for building exit transactions
+     * * `fee_rate_sat_per_vb` - Optional fee rate override in sats/vB
+     */
+    progressExits(onchainWallet: OnchainWalletInterface, feeRateSatPerVb: /*u64*/ bigint | undefined): Array<ExitProgressStatus>;
+    /**
+     * Progress pending rounds
+     *
+     * Advances the state of all pending rounds. Call periodically.
+     */
+    progressPendingRounds(): void;
+    properties(): WalletProperties;
+    /**
+     * Refresh the Ark server connection
+     *
+     * Re-establishes connection if it was lost.
+     */
+    refreshServer(): void;
+    /**
+     * Refresh specific VTXOs
+     */
+    refreshVtxos(vtxoIds: Array<string>): /*throws*/ string | undefined;
+    sendArkoorPayment(arkAddress: string, amountSats: bigint): string;
+    /**
+     * Send an onchain payment during a round
+     */
+    sendRoundOnchainPayment(address: string, amountSats: bigint): string;
+    /**
+     * Sign exit claim inputs in an external PSBT
+     *
+     * This is useful if you want to combine exit claims with other inputs
+     * in a single transaction.
+     *
+     * # Arguments
+     *
+     * * `psbt_base64` - Base64-encoded PSBT to sign
+     *
+     * Returns the signed PSBT
+     */
+    signExitClaimInputs(psbtBase64: string): string;
+    /**
+     * Get all spendable VTXOs
+     */
+    spendableVtxos(): Array<Vtxo>;
+    /**
+     * Start unilateral exit for the entire wallet
+     */
+    startExitForEntireWallet(): void;
+    /**
+     * Start unilateral exit for specific VTXOs
+     *
+     * Marks specific VTXOs for exit. Call progress_exits() to actually advance them.
+     */
+    startExitForVtxos(vtxoIds: Array<string>): void;
+    /**
+     * Lightweight sync with Ark server and blockchain
+     * Note: Bark's sync() handles errors internally with logging.
+     * The Throws annotation is for forward compatibility only.
+     */
+    sync(): void;
+    /**
+     * Sync exit state (checks status but doesn't progress)
+     */
+    syncExits(onchainWallet: OnchainWalletInterface): void;
+    /**
+     * Sync pending board transactions
+     */
+    syncPendingBoards(): void;
+    tryClaimAllLightningReceives(wait: boolean): void;
+    /**
+     * Try to claim a specific lightning receive by payment hash
+     *
+     * # Arguments
+     *
+     * * `payment_hash` - Payment hash as hex string
+     * * `wait` - Whether to wait for claim to complete
+     */
+    tryClaimLightningReceive(paymentHash: string, wait: boolean): void;
+    /**
+     * Validate an Ark address against the connected server
+     *
+     * This performs full validation including checking if the address
+     * belongs to the currently connected Ark server.
+     * For basic format validation only, use validate_ark_address() instead.
+     */
+    validateArkoorAddress(address: string): boolean;
+    vtxos(): Array<Vtxo>;
+}
+/**
+ * The main Bark wallet interface for Ark operations
+ */
+export declare class Wallet extends UniffiAbstractObject implements WalletInterface {
+    readonly [uniffiTypeNameSymbol] = "Wallet";
+    readonly [destructorGuardSymbol]: UniffiRustArcPtr;
+    readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
+    private constructor();
+    /**
+     * Create a new Bark wallet
+     */
+    static create(mnemonic: string, config: Config, datadir: string, forceRescan: boolean): WalletInterface;
+    /**
+     * Create a new Bark wallet WITH onchain capabilities
+     */
+    static createWithOnchain(mnemonic: string, config: Config, datadir: string, onchainWallet: OnchainWalletInterface, forceRescan: boolean): WalletInterface;
+    /**
+     * Open an existing Bark wallet
+     */
+    static open(mnemonic: string, config: Config, datadir: string): WalletInterface;
+    /**
+     * Open an existing Bark wallet WITH onchain capabilities
+     */
+    static openWithOnchain(mnemonic: string, config: Config, datadir: string, onchainWallet: OnchainWalletInterface): WalletInterface;
+    /**
+     * Get earliest block height when all exits will be claimable
+     *
+     * Returns null if no exits or any exit has undetermined claimability.
+     */
+    allExitsClaimableAtHeight(): /*u32*/ number | undefined;
+    /**
+     * Get all VTXOs (including spent)
+     */
+    allVtxos(): Array<Vtxo>;
+    /**
+     * Get Ark server info (null if not connected)
+     */
+    arkInfo(): ArkInfo | undefined;
+    balance(): Balance;
+    /**
+     * Board all funds from onchain wallet into Ark
+     */
+    boardAll(onchainWallet: OnchainWalletInterface): PendingBoard;
+    /**
+     * Board a specific amount from onchain wallet into Ark
+     */
+    boardAmount(onchainWallet: OnchainWalletInterface, amountSats: bigint): PendingBoard;
+    bolt11Invoice(amountSats: bigint): LightningInvoice;
+    /**
+     * Broadcast a signed transaction to the Bitcoin network
+     *
+     * Takes a hex-encoded transaction and broadcasts it via the wallet's chain source.
+     * This is useful after extracting a transaction from a PSBT using extract_tx_from_psbt.
+     *
+     * # Arguments
+     *
+     * * `tx_hex` - Hex-encoded signed transaction
+     *
+     * Returns the transaction ID (txid) of the broadcasted transaction
+     */
+    broadcastTx(txHex: string): string;
+    /**
+     * Cancel all pending rounds
+     */
+    cancelAllPendingRounds(): void;
+    /**
+     * Cancel a specific pending round
+     */
+    cancelPendingRound(roundId: number): void;
+    /**
+     * Check lightning payment status by payment hash
+     *
+     * # Arguments
+     *
+     * * `payment_hash` - Payment hash as hex string
+     * * `wait` - Whether to wait for the payment to complete
+     *
+     * Returns the preimage if payment is successful, null if still pending
+     */
+    checkLightningPayment(paymentHash: string, wait: boolean): string | undefined;
+    /**
+     * Get claimable lightning receive balance
+     */
+    claimableLightningReceiveBalanceSats(): bigint;
+    /**
+     * Get wallet config
+     */
+    config(): Config;
+    /**
+     * Drain claimable exits to an address
+     *
+     * Builds a signed PSBT that claims exited funds and sends them to the address.
+     * The PSBT can be broadcast directly or modified before broadcasting.
+     *
+     * # Arguments
+     *
+     * * `vtxo_ids` - List of claimable VTXO IDs to drain (empty = drain all)
+     * * `address` - Bitcoin address to send claimed funds to
+     * * `fee_rate_sat_per_vb` - Optional fee rate override in sats/vB
+     */
+    drainExits(vtxoIds: Array<string>, address: string, feeRateSatPerVb: /*u64*/ bigint | undefined): ExitClaimTransaction;
+    /**
+     * Get detailed exit status for a specific VTXO
+     *
+     * Returns detailed status including current state, history, and transactions.
+     *
+     * # Arguments
+     *
+     * * `vtxo_id` - The VTXO ID to check
+     * * `include_history` - Whether to include full state machine history
+     * * `include_transactions` - Whether to include transaction details
+     */
+    getExitStatus(vtxoId: string, includeHistory: boolean, includeTransactions: boolean): ExitTransactionStatus | undefined;
+    /**
+     * Get all VTXOs currently in exit process
+     */
+    getExitVtxos(): Array<ExitVtxo>;
+    /**
+     * Get VTXOs expiring within threshold blocks
+     */
+    getExpiringVtxos(thresholdBlocks: number): Array<Vtxo>;
+    /**
+     * Get the block height of the first expiring VTXO
+     *
+     * Returns null if there are no spendable VTXOs.
+     */
+    getFirstExpiringVtxoBlockheight(): number | undefined;
+    /**
+     * Get the next block height when a refresh should be performed
+     *
+     * This is calculated as the first expiring VTXO height minus the refresh threshold.
+     * Returns null if there are no VTXOs to refresh.
+     */
+    getNextRequiredRefreshBlockheight(): number | undefined;
+    /**
+     * Get a specific VTXO by ID
+     */
+    getVtxoById(vtxoId: string): Vtxo;
+    /**
+     * Get VTXOs that should be refreshed
+     */
+    getVtxosToRefresh(): Array<Vtxo>;
+    /**
+     * Check if any exits are pending
+     */
+    hasPendingExits(): boolean;
+    /**
+     * Get all wallet movements (transaction history)
+     */
+    history(): Array<Movement>;
+    /**
+     * Get lightning receive status by payment hash
+     *
+     * # Arguments
+     *
+     * * `payment_hash` - Payment hash as hex string
+     */
+    lightningReceiveStatus(paymentHash: string): LightningReceive | undefined;
+    /**
+     * List all exits that are claimable
+     *
+     * Returns exits ready to be drained to onchain wallet.
+     */
+    listClaimableExits(): Array<ExitVtxo>;
+    maintenance(): void;
+    /**
+     * Perform maintenance refresh
+     */
+    maintenanceRefresh(): string | undefined;
+    /**
+     * Full maintenance including onchain wallet sync
+     *
+     * More thorough than maintenance() - also syncs onchain wallet and exits.
+     */
+    maintenanceWithOnchain(onchainWallet: OnchainWalletInterface): void;
+    /**
+     * Schedule a maintenance refresh if VTXOs need refreshing
+     *
+     * Returns the round ID if a refresh was scheduled, null otherwise.
+     */
+    maybeScheduleMaintenanceRefresh(): number | undefined;
+    newAddress(): string;
+    /**
+     * Generate a new address and return it with its index
+     */
+    newAddressWithIndex(): AddressWithIndex;
+    offboardAll(bitcoinAddress: string): OffboardResult;
+    /**
+     * Offboard specific VTXOs to a Bitcoin address
+     */
+    offboardVtxos(vtxoIds: Array<string>, bitcoinAddress: string): string;
+    payLightningAddress(lightningAddress: string, amountSats: bigint, comment: string | undefined): LightningSend;
+    payLightningInvoice(invoice: string, amountSats: /*u64*/ bigint | undefined): LightningSend;
+    /**
+     * Pay a BOLT12 lightning offer
+     *
+     * # Arguments
+     *
+     * * `offer` - BOLT12 offer string
+     * * `amount_sats` - Optional amount in sats (required if offer doesn't specify amount)
+     */
+    payLightningOffer(offer: string, amountSats: /*u64*/ bigint | undefined): LightningSend;
+    /**
+     * Peek at an address at a specific index
+     */
+    peakAddress(index: number): string;
+    /**
+     * Get total amount in pending exits (sats)
+     */
+    pendingExitsTotalSats(): bigint;
+    /**
+     * Get all pending lightning receives
+     */
+    pendingLightningReceives(): Array<LightningReceive>;
+    /**
+     * Get all pending lightning sends
+     */
+    pendingLightningSends(): Array<LightningSend>;
+    /**
+     * Get all pending round states
+     */
+    pendingRoundStates(): Array<RoundState>;
+    /**
+     * Progress unilateral exits (broadcast, fee bump, advance state machine)
+     *
+     * This is the critical method for actually moving exits forward.
+     * Call periodically after starting exits.
+     *
+     * # Arguments
+     *
+     * * `onchain_wallet` - Onchain wallet for building exit transactions
+     * * `fee_rate_sat_per_vb` - Optional fee rate override in sats/vB
+     */
+    progressExits(onchainWallet: OnchainWalletInterface, feeRateSatPerVb: /*u64*/ bigint | undefined): Array<ExitProgressStatus>;
+    /**
+     * Progress pending rounds
+     *
+     * Advances the state of all pending rounds. Call periodically.
+     */
+    progressPendingRounds(): void;
+    properties(): WalletProperties;
+    /**
+     * Refresh the Ark server connection
+     *
+     * Re-establishes connection if it was lost.
+     */
+    refreshServer(): void;
+    /**
+     * Refresh specific VTXOs
+     */
+    refreshVtxos(vtxoIds: Array<string>): string | undefined;
+    sendArkoorPayment(arkAddress: string, amountSats: bigint): string;
+    /**
+     * Send an onchain payment during a round
+     */
+    sendRoundOnchainPayment(address: string, amountSats: bigint): string;
+    /**
+     * Sign exit claim inputs in an external PSBT
+     *
+     * This is useful if you want to combine exit claims with other inputs
+     * in a single transaction.
+     *
+     * # Arguments
+     *
+     * * `psbt_base64` - Base64-encoded PSBT to sign
+     *
+     * Returns the signed PSBT
+     */
+    signExitClaimInputs(psbtBase64: string): string;
+    /**
+     * Get all spendable VTXOs
+     */
+    spendableVtxos(): Array<Vtxo>;
+    /**
+     * Start unilateral exit for the entire wallet
+     */
+    startExitForEntireWallet(): void;
+    /**
+     * Start unilateral exit for specific VTXOs
+     *
+     * Marks specific VTXOs for exit. Call progress_exits() to actually advance them.
+     */
+    startExitForVtxos(vtxoIds: Array<string>): void;
+    /**
+     * Lightweight sync with Ark server and blockchain
+     * Note: Bark's sync() handles errors internally with logging.
+     * The Throws annotation is for forward compatibility only.
+     */
+    sync(): void;
+    /**
+     * Sync exit state (checks status but doesn't progress)
+     */
+    syncExits(onchainWallet: OnchainWalletInterface): void;
+    /**
+     * Sync pending board transactions
+     */
+    syncPendingBoards(): void;
+    tryClaimAllLightningReceives(wait: boolean): void;
+    /**
+     * Try to claim a specific lightning receive by payment hash
+     *
+     * # Arguments
+     *
+     * * `payment_hash` - Payment hash as hex string
+     * * `wait` - Whether to wait for claim to complete
+     */
+    tryClaimLightningReceive(paymentHash: string, wait: boolean): void;
+    /**
+     * Validate an Ark address against the connected server
+     *
+     * This performs full validation including checking if the address
+     * belongs to the currently connected Ark server.
+     * For basic format validation only, use validate_ark_address() instead.
+     */
+    validateArkoorAddress(address: string): boolean;
+    vtxos(): Array<Vtxo>;
+    /**
+     * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+     */
+    uniffiDestroy(): void;
+    static instanceOf(obj: any): obj is Wallet;
+}
+/**
+ * This should be called before anything else.
+ *
+ * It is likely that this is being done for you by the library's `index.ts`.
+ *
+ * It checks versions of uniffi between when the Rust scaffolding was generated
+ * and when the bindings were generated.
+ *
+ * It also initializes the machinery to enable Rust to talk back to Javascript.
+ */
+declare function uniffiEnsureInitialized(): void;
+declare const _default: Readonly<{
+    initialize: typeof uniffiEnsureInitialized;
+    converters: {
+        FfiConverterTypeAddressWithIndex: {
+            read(from: RustBuffer): AddressWithIndex;
+            write(value: AddressWithIndex, into: RustBuffer): void;
+            allocationSize(value: AddressWithIndex): number;
+            lift(value: UniffiByteArray): AddressWithIndex;
+            lower(value: AddressWithIndex): UniffiByteArray;
+        };
+        FfiConverterTypeArkInfo: {
+            read(from: RustBuffer): ArkInfo;
+            write(value: ArkInfo, into: RustBuffer): void;
+            allocationSize(value: ArkInfo): number;
+            lift(value: UniffiByteArray): ArkInfo;
+            lower(value: ArkInfo): UniffiByteArray;
+        };
+        FfiConverterTypeBalance: {
+            read(from: RustBuffer): Balance;
+            write(value: Balance, into: RustBuffer): void;
+            allocationSize(value: Balance): number;
+            lift(value: UniffiByteArray): Balance;
+            lower(value: Balance): UniffiByteArray;
+        };
+        FfiConverterTypeBarkError: {
+            read(from: RustBuffer): BarkError;
+            write(value: BarkError, into: RustBuffer): void;
+            allocationSize(value: BarkError): number;
+            lift(value: UniffiByteArray): BarkError;
+            lower(value: BarkError): UniffiByteArray;
+        };
+        FfiConverterTypeBlockRef: {
+            read(from: RustBuffer): BlockRef;
+            write(value: BlockRef, into: RustBuffer): void;
+            allocationSize(value: BlockRef): number;
+            lift(value: UniffiByteArray): BlockRef;
+            lower(value: BlockRef): UniffiByteArray;
+        };
+        FfiConverterTypeConfig: {
+            read(from: RustBuffer): Config;
+            write(value: Config, into: RustBuffer): void;
+            allocationSize(value: Config): number;
+            lift(value: UniffiByteArray): Config;
+            lower(value: Config): UniffiByteArray;
+        };
+        FfiConverterTypeCpfpParams: {
+            read(from: RustBuffer): CpfpParams;
+            write(value: CpfpParams, into: RustBuffer): void;
+            allocationSize(value: CpfpParams): number;
+            lift(value: UniffiByteArray): CpfpParams;
+            lower(value: CpfpParams): UniffiByteArray;
+        };
+        FfiConverterTypeDestination: {
+            read(from: RustBuffer): Destination;
+            write(value: Destination, into: RustBuffer): void;
+            allocationSize(value: Destination): number;
+            lift(value: UniffiByteArray): Destination;
+            lower(value: Destination): UniffiByteArray;
+        };
+        FfiConverterTypeExitClaimTransaction: {
+            read(from: RustBuffer): ExitClaimTransaction;
+            write(value: ExitClaimTransaction, into: RustBuffer): void;
+            allocationSize(value: ExitClaimTransaction): number;
+            lift(value: UniffiByteArray): ExitClaimTransaction;
+            lower(value: ExitClaimTransaction): UniffiByteArray;
+        };
+        FfiConverterTypeExitProgressStatus: {
+            read(from: RustBuffer): ExitProgressStatus;
+            write(value: ExitProgressStatus, into: RustBuffer): void;
+            allocationSize(value: ExitProgressStatus): number;
+            lift(value: UniffiByteArray): ExitProgressStatus;
+            lower(value: ExitProgressStatus): UniffiByteArray;
+        };
+        FfiConverterTypeExitTransactionStatus: {
+            read(from: RustBuffer): ExitTransactionStatus;
+            write(value: ExitTransactionStatus, into: RustBuffer): void;
+            allocationSize(value: ExitTransactionStatus): number;
+            lift(value: UniffiByteArray): ExitTransactionStatus;
+            lower(value: ExitTransactionStatus): UniffiByteArray;
+        };
+        FfiConverterTypeExitVtxo: {
+            read(from: RustBuffer): ExitVtxo;
+            write(value: ExitVtxo, into: RustBuffer): void;
+            allocationSize(value: ExitVtxo): number;
+            lift(value: UniffiByteArray): ExitVtxo;
+            lower(value: ExitVtxo): UniffiByteArray;
+        };
+        FfiConverterTypeLightningInvoice: {
+            read(from: RustBuffer): LightningInvoice;
+            write(value: LightningInvoice, into: RustBuffer): void;
+            allocationSize(value: LightningInvoice): number;
+            lift(value: UniffiByteArray): LightningInvoice;
+            lower(value: LightningInvoice): UniffiByteArray;
+        };
+        FfiConverterTypeLightningReceive: {
+            read(from: RustBuffer): LightningReceive;
+            write(value: LightningReceive, into: RustBuffer): void;
+            allocationSize(value: LightningReceive): number;
+            lift(value: UniffiByteArray): LightningReceive;
+            lower(value: LightningReceive): UniffiByteArray;
+        };
+        FfiConverterTypeLightningSend: {
+            read(from: RustBuffer): LightningSend;
+            write(value: LightningSend, into: RustBuffer): void;
+            allocationSize(value: LightningSend): number;
+            lift(value: UniffiByteArray): LightningSend;
+            lower(value: LightningSend): UniffiByteArray;
+        };
+        FfiConverterTypeMovement: {
+            read(from: RustBuffer): Movement;
+            write(value: Movement, into: RustBuffer): void;
+            allocationSize(value: Movement): number;
+            lift(value: UniffiByteArray): Movement;
+            lower(value: Movement): UniffiByteArray;
+        };
+        FfiConverterTypeNetwork: {
+            read(from: RustBuffer): Network;
+            write(value: Network, into: RustBuffer): void;
+            allocationSize(value: Network): number;
+            lift(value: UniffiByteArray): Network;
+            lower(value: Network): UniffiByteArray;
+        };
+        FfiConverterTypeOffboardResult: {
+            read(from: RustBuffer): OffboardResult;
+            write(value: OffboardResult, into: RustBuffer): void;
+            allocationSize(value: OffboardResult): number;
+            lift(value: UniffiByteArray): OffboardResult;
+            lower(value: OffboardResult): UniffiByteArray;
+        };
+        FfiConverterTypeOnchainBalance: {
+            read(from: RustBuffer): OnchainBalance;
+            write(value: OnchainBalance, into: RustBuffer): void;
+            allocationSize(value: OnchainBalance): number;
+            lift(value: UniffiByteArray): OnchainBalance;
+            lower(value: OnchainBalance): UniffiByteArray;
+        };
+        FfiConverterTypeOnchainWallet: FfiConverterObject<OnchainWalletInterface>;
+        FfiConverterTypeOutPoint: {
+            read(from: RustBuffer): OutPoint;
+            write(value: OutPoint, into: RustBuffer): void;
+            allocationSize(value: OutPoint): number;
+            lift(value: UniffiByteArray): OutPoint;
+            lower(value: OutPoint): UniffiByteArray;
+        };
+        FfiConverterTypePendingBoard: {
+            read(from: RustBuffer): PendingBoard;
+            write(value: PendingBoard, into: RustBuffer): void;
+            allocationSize(value: PendingBoard): number;
+            lift(value: UniffiByteArray): PendingBoard;
+            lower(value: PendingBoard): UniffiByteArray;
+        };
+        FfiConverterTypeRoundState: {
+            read(from: RustBuffer): RoundState;
+            write(value: RoundState, into: RustBuffer): void;
+            allocationSize(value: RoundState): number;
+            lift(value: UniffiByteArray): RoundState;
+            lower(value: RoundState): UniffiByteArray;
+        };
+        FfiConverterTypeVtxo: {
+            read(from: RustBuffer): Vtxo;
+            write(value: Vtxo, into: RustBuffer): void;
+            allocationSize(value: Vtxo): number;
+            lift(value: UniffiByteArray): Vtxo;
+            lower(value: Vtxo): UniffiByteArray;
+        };
+        FfiConverterTypeWallet: FfiConverterObject<WalletInterface>;
+        FfiConverterTypeWalletProperties: {
+            read(from: RustBuffer): WalletProperties;
+            write(value: WalletProperties, into: RustBuffer): void;
+            allocationSize(value: WalletProperties): number;
+            lift(value: UniffiByteArray): WalletProperties;
+            lower(value: WalletProperties): UniffiByteArray;
+        };
+    };
+}>;
+export default _default;
+//# sourceMappingURL=bark.d.ts.map