@breeztech/breez-sdk-spark-react-native 0.19.2 → 0.21.0

package/lib/typescript/commonjs/src/generated/breez_sdk_spark.d.ts

@@ -187,6 +187,11 @@ export declare function newRestChainService(url: string, network: Network, apiTy
 export declare function newSharedSdkContext(config: SdkContextConfig, asyncOpts_?: {
     signal: AbortSignal;
 }): Promise<SdkContextInterface>;
+/**
+ * A CPFP signer backed by a single private key. Signs P2WPKH and P2TR key-path
+ * inputs only; taproot script-path spends are not supported.
+ */
+export declare function singleKeyCpfpSigner(secretKeyBytes: ArrayBuffer): CpfpSigner;
 /**
  * Trait for event listeners
  */
@@ -330,6 +335,76 @@ export declare const AuthorizeTransferRequest: Readonly<{
      */
     defaults: () => Partial<AuthorizeTransferRequest>;
 }>;
+/**
+ * A single payee in a batch send.
+ */
+export type BatchRecipient = {
+    /**
+     * Spark address or Spark invoice identifying the payee.
+     */
+    paymentRequest: string;
+    /**
+     * Amount to send, in the base units of the asset being sent. Required
+     * unless `payment_request` is an invoice that carries its own amount.
+     */
+    amount: U128 | undefined;
+    /**
+     * Token to send. Unset means sats, which a batch cannot send yet, so a
+     * plain address needs this set. An invoice that names a token does not.
+     */
+    tokenIdentifier: string | undefined;
+};
+/**
+ * Generated factory for {@link BatchRecipient} record objects.
+ */
+export declare const BatchRecipient: Readonly<{
+    /**
+     * Create a frozen instance of {@link BatchRecipient}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create: (partial: Partial<BatchRecipient> & Required<Omit<BatchRecipient, "amount" | "tokenIdentifier">>) => BatchRecipient;
+    /**
+     * Create a frozen instance of {@link BatchRecipient}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: (partial: Partial<BatchRecipient> & Required<Omit<BatchRecipient, "amount" | "tokenIdentifier">>) => BatchRecipient;
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Partial<BatchRecipient>;
+}>;
+/**
+ * What a batch debits for one asset.
+ */
+export type BatchTotal = {
+    /**
+     * The token debited. Unset means sats, which a batch cannot send yet.
+     */
+    tokenIdentifier: string | undefined;
+    /**
+     * Amount in the asset's base units.
+     */
+    amount: U128;
+};
+/**
+ * Generated factory for {@link BatchTotal} record objects.
+ */
+export declare const BatchTotal: Readonly<{
+    /**
+     * Create a frozen instance of {@link BatchTotal}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create: (partial: Partial<BatchTotal> & Required<Omit<BatchTotal, never>>) => BatchTotal;
+    /**
+     * Create a frozen instance of {@link BatchTotal}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: (partial: Partial<BatchTotal> & Required<Omit<BatchTotal, never>>) => BatchTotal;
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Partial<BatchTotal>;
+}>;
 export type Bip21Details = {
     amountSat: /*u64*/ bigint | undefined;
     assetId: string | undefined;
@@ -669,6 +744,28 @@ export declare const Bolt12OfferDetails: Readonly<{
      */
     defaults: () => Partial<Bolt12OfferDetails>;
 }>;
+export type BuildUnsignedBatchPackageRequest = {
+    prepareResponse: PrepareSendBatchResponse;
+};
+/**
+ * Generated factory for {@link BuildUnsignedBatchPackageRequest} record objects.
+ */
+export declare const BuildUnsignedBatchPackageRequest: Readonly<{
+    /**
+     * Create a frozen instance of {@link BuildUnsignedBatchPackageRequest}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create: (partial: Partial<BuildUnsignedBatchPackageRequest> & Required<Omit<BuildUnsignedBatchPackageRequest, never>>) => BuildUnsignedBatchPackageRequest;
+    /**
+     * Create a frozen instance of {@link BuildUnsignedBatchPackageRequest}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: (partial: Partial<BuildUnsignedBatchPackageRequest> & Required<Omit<BuildUnsignedBatchPackageRequest, never>>) => BuildUnsignedBatchPackageRequest;
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Partial<BuildUnsignedBatchPackageRequest>;
+}>;
 export type BuildUnsignedLnurlPayPackageRequest = {
     prepareResponse: PrepareLnurlPayResponse;
 };
@@ -1604,6 +1701,42 @@ export declare const CreateIssuerTokenRequest: Readonly<{
      */
     defaults: () => Partial<CreateIssuerTokenRequest>;
 }>;
+/**
+ * A newly created credential, plus the PRF outputs when the platform
+ * evaluated them during the create ceremony itself.
+ *
+ * `seeds` present means no assertion is needed: the caller skips the
+ * second ceremony, and with it the window in which a credential exists
+ * but is not yet resolvable. Absent means the platform returned no PRF
+ * results at create (or dropped one of a pair), so the caller derives
+ * through [`super::PrfProvider::derive_seeds`] as before.
+ */
+export type CreatePasskeyOutput = {
+    credential: PasskeyCredential;
+    /**
+     * One output per requested salt, in request order.
+     */
+    seeds: Array<ArrayBuffer> | undefined;
+};
+/**
+ * Generated factory for {@link CreatePasskeyOutput} record objects.
+ */
+export declare const CreatePasskeyOutput: Readonly<{
+    /**
+     * Create a frozen instance of {@link CreatePasskeyOutput}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create: (partial: Partial<CreatePasskeyOutput> & Required<Omit<CreatePasskeyOutput, never>>) => CreatePasskeyOutput;
+    /**
+     * Create a frozen instance of {@link CreatePasskeyOutput}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: (partial: Partial<CreatePasskeyOutput> & Required<Omit<CreatePasskeyOutput, never>>) => CreatePasskeyOutput;
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Partial<CreatePasskeyOutput>;
+}>;
 export type Credentials = {
     username: string;
     password: string;
@@ -4487,6 +4620,38 @@ export declare const PaymentRequestSource: Readonly<{
      */
     defaults: () => Partial<PaymentRequestSource>;
 }>;
+/**
+ * How much to fund one branch of the exit to avoid a fan-out.
+ */
+export type PerBranchFunding = {
+    /**
+     * The leaf whose branch this funds.
+     */
+    leafId: string;
+    /**
+     * Fund a UTXO of at least this many satoshis for this branch.
+     */
+    fundingSat: bigint;
+};
+/**
+ * Generated factory for {@link PerBranchFunding} record objects.
+ */
+export declare const PerBranchFunding: Readonly<{
+    /**
+     * Create a frozen instance of {@link PerBranchFunding}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create: (partial: Partial<PerBranchFunding> & Required<Omit<PerBranchFunding, never>>) => PerBranchFunding;
+    /**
+     * Create a frozen instance of {@link PerBranchFunding}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: (partial: Partial<PerBranchFunding> & Required<Omit<PerBranchFunding, never>>) => PerBranchFunding;
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Partial<PerBranchFunding>;
+}>;
 export type PrepareLnurlPayRequest = {
     /**
      * The amount to send. Denominated in satoshis, or in token base units
@@ -4575,6 +4740,63 @@ export declare const PrepareLnurlPayResponse: Readonly<{
      */
     defaults: () => Partial<PrepareLnurlPayResponse>;
 }>;
+export type PrepareSendBatchRequest = {
+    /**
+     * The payees, all paid by one transaction. They may span several tokens,
+     * and may mix Spark addresses with Spark invoices. Once a Spark invoice is
+     * among them, every recipient must be paid in the same token.
+     */
+    recipients: Array<BatchRecipient>;
+};
+/**
+ * Generated factory for {@link PrepareSendBatchRequest} record objects.
+ */
+export declare const PrepareSendBatchRequest: Readonly<{
+    /**
+     * Create a frozen instance of {@link PrepareSendBatchRequest}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create: (partial: Partial<PrepareSendBatchRequest> & Required<Omit<PrepareSendBatchRequest, never>>) => PrepareSendBatchRequest;
+    /**
+     * Create a frozen instance of {@link PrepareSendBatchRequest}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: (partial: Partial<PrepareSendBatchRequest> & Required<Omit<PrepareSendBatchRequest, never>>) => PrepareSendBatchRequest;
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Partial<PrepareSendBatchRequest>;
+}>;
+export type PrepareSendBatchResponse = {
+    /**
+     * The payees in the order they were requested, which is the order their
+     * payments come back in.
+     */
+    recipients: Array<ResolvedBatchRecipient>;
+    /**
+     * What the batch debits, one entry per distinct asset.
+     */
+    totals: Array<BatchTotal>;
+};
+/**
+ * Generated factory for {@link PrepareSendBatchResponse} record objects.
+ */
+export declare const PrepareSendBatchResponse: Readonly<{
+    /**
+     * Create a frozen instance of {@link PrepareSendBatchResponse}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create: (partial: Partial<PrepareSendBatchResponse> & Required<Omit<PrepareSendBatchResponse, never>>) => PrepareSendBatchResponse;
+    /**
+     * Create a frozen instance of {@link PrepareSendBatchResponse}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: (partial: Partial<PrepareSendBatchResponse> & Required<Omit<PrepareSendBatchResponse, never>>) => PrepareSendBatchResponse;
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Partial<PrepareSendBatchResponse>;
+}>;
 export type PrepareSendPaymentRequest = {
     paymentRequest: PaymentRequest;
     /**
@@ -4666,6 +4888,98 @@ export declare const PrepareSendPaymentResponse: Readonly<{
      */
     defaults: () => Partial<PrepareSendPaymentResponse>;
 }>;
+/**
+ * Request for `prepare_unilateral_exit`, the exit quote.
+ */
+export type PrepareUnilateralExitRequest = {
+    /**
+     * Target fee rate in sat/vByte, applied to every CPFP child, the fan-out,
+     * and the sweep.
+     */
+    feeRateSatPerVbyte: bigint;
+    fundingKind: CpfpFundingKind;
+    /**
+     * The Bitcoin address the swept funds are sent to.
+     */
+    destination: string;
+    selection: ExitLeafSelection;
+};
+/**
+ * Generated factory for {@link PrepareUnilateralExitRequest} record objects.
+ */
+export declare const PrepareUnilateralExitRequest: Readonly<{
+    /**
+     * Create a frozen instance of {@link PrepareUnilateralExitRequest}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create: (partial: Partial<PrepareUnilateralExitRequest> & Required<Omit<PrepareUnilateralExitRequest, never>>) => PrepareUnilateralExitRequest;
+    /**
+     * Create a frozen instance of {@link PrepareUnilateralExitRequest}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: (partial: Partial<PrepareUnilateralExitRequest> & Required<Omit<PrepareUnilateralExitRequest, never>>) => PrepareUnilateralExitRequest;
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Partial<PrepareUnilateralExitRequest>;
+}>;
+/**
+ * Response from `prepare_unilateral_exit`: which leaves would exit, the exact
+ * fee at the requested rate, and how much to fund.
+ */
+export type PrepareUnilateralExitResponse = {
+    leaves: Array<UnilateralExitLeaf>;
+    /**
+     * Total value of the selected leaves, in satoshis.
+     */
+    recoverableValueSat: bigint;
+    /**
+     * Total on-chain fee when funding with a single UTXO (fanned out across
+     * branches), in satoshis. Exact for the given funding kind; nodes the
+     * operators report on-chain are assumed already paid, so a partially-exited
+     * tree quotes a lower fee than a fresh one.
+     */
+    totalFeeSat: bigint;
+    /**
+     * The part of `total_fee_sat` paid for the fan-out transaction. Funding one
+     * UTXO per branch (`per_branch_funding`) avoids it. Zero for a single
+     * branch (no fan-out).
+     */
+    fanoutFeeSat: bigint;
+    /**
+     * Fund a single UTXO of at least this many satoshis to exit with a fan-out.
+     */
+    singleUtxoFundingSat: bigint;
+    /**
+     * To skip the fan-out, fund one UTXO per branch of at least the given
+     * amount (one entry per selected leaf).
+     */
+    perBranchFunding: Array<PerBranchFunding>;
+    /**
+     * The fee rate this quote was computed at, in sat/vByte.
+     */
+    feeRateSatPerVbyte: bigint;
+    destination: string;
+};
+/**
+ * Generated factory for {@link PrepareUnilateralExitResponse} record objects.
+ */
+export declare const PrepareUnilateralExitResponse: Readonly<{
+    /**
+     * Create a frozen instance of {@link PrepareUnilateralExitResponse}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create: (partial: Partial<PrepareUnilateralExitResponse> & Required<Omit<PrepareUnilateralExitResponse, never>>) => PrepareUnilateralExitResponse;
+    /**
+     * Create a frozen instance of {@link PrepareUnilateralExitResponse}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: (partial: Partial<PrepareUnilateralExitResponse> & Required<Omit<PrepareUnilateralExitResponse, never>>) => PrepareUnilateralExitResponse;
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Partial<PrepareUnilateralExitResponse>;
+}>;
 export type ProvisionalPayment = {
     /**
      * Unique identifier for the payment
@@ -5015,6 +5329,44 @@ export declare const RefundDepositResponse: Readonly<{
      */
     defaults: () => Partial<RefundDepositResponse>;
 }>;
+/**
+ * Response from refunding pending conversions.
+ */
+export type RefundPendingConversionsResponse = {
+    /**
+     * Conversions successfully refunded this pass.
+     */
+    refunded: number;
+    /**
+     * Conversions intentionally deferred (eligible but held back by a
+     * safety window). The next pass will retry them.
+     */
+    skipped: number;
+    /**
+     * Conversions whose clawback did not complete this pass (rejected or
+     * errored; funds not returned). The next pass will retry them.
+     */
+    failed: number;
+};
+/**
+ * Generated factory for {@link RefundPendingConversionsResponse} record objects.
+ */
+export declare const RefundPendingConversionsResponse: Readonly<{
+    /**
+     * Create a frozen instance of {@link RefundPendingConversionsResponse}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create: (partial: Partial<RefundPendingConversionsResponse> & Required<Omit<RefundPendingConversionsResponse, never>>) => RefundPendingConversionsResponse;
+    /**
+     * Create a frozen instance of {@link RefundPendingConversionsResponse}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: (partial: Partial<RefundPendingConversionsResponse> & Required<Omit<RefundPendingConversionsResponse, never>>) => RefundPendingConversionsResponse;
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Partial<RefundPendingConversionsResponse>;
+}>;
 export type RegisterLightningAddressRequest = {
     username: string;
     description: string | undefined;
@@ -5176,6 +5528,40 @@ export declare const RegisterWebhookResponse: Readonly<{
      */
     defaults: () => Partial<RegisterWebhookResponse>;
 }>;
+/**
+ * A recipient after prepare has resolved the asset and amount it is owed.
+ */
+export type ResolvedBatchRecipient = {
+    destination: BatchDestination;
+    /**
+     * Amount in the base units of the asset this recipient is paid in.
+     */
+    amount: U128;
+    /**
+     * The token this recipient is paid in. Unset means sats, which a batch
+     * cannot send yet.
+     */
+    tokenIdentifier: string | undefined;
+};
+/**
+ * Generated factory for {@link ResolvedBatchRecipient} record objects.
+ */
+export declare const ResolvedBatchRecipient: Readonly<{
+    /**
+     * Create a frozen instance of {@link ResolvedBatchRecipient}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create: (partial: Partial<ResolvedBatchRecipient> & Required<Omit<ResolvedBatchRecipient, never>>) => ResolvedBatchRecipient;
+    /**
+     * Create a frozen instance of {@link ResolvedBatchRecipient}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: (partial: Partial<ResolvedBatchRecipient> & Required<Omit<ResolvedBatchRecipient, never>>) => ResolvedBatchRecipient;
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Partial<ResolvedBatchRecipient>;
+}>;
 export type RestResponse = {
     status: number;
     body: string;
@@ -5303,6 +5689,54 @@ export declare const SecretBytes: Readonly<{
      */
     defaults: () => Partial<SecretBytes>;
 }>;
+export type SendBatchRequest = {
+    prepareResponse: PrepareSendBatchResponse;
+};
+/**
+ * Generated factory for {@link SendBatchRequest} record objects.
+ */
+export declare const SendBatchRequest: Readonly<{
+    /**
+     * Create a frozen instance of {@link SendBatchRequest}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create: (partial: Partial<SendBatchRequest> & Required<Omit<SendBatchRequest, never>>) => SendBatchRequest;
+    /**
+     * Create a frozen instance of {@link SendBatchRequest}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: (partial: Partial<SendBatchRequest> & Required<Omit<SendBatchRequest, never>>) => SendBatchRequest;
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Partial<SendBatchRequest>;
+}>;
+export type SendBatchResponse = {
+    /**
+     * One payment per recipient, in recipient order, all sharing a transaction
+     * hash.
+     */
+    payments: Array<Payment>;
+};
+/**
+ * Generated factory for {@link SendBatchResponse} record objects.
+ */
+export declare const SendBatchResponse: Readonly<{
+    /**
+     * Create a frozen instance of {@link SendBatchResponse}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create: (partial: Partial<SendBatchResponse> & Required<Omit<SendBatchResponse, never>>) => SendBatchResponse;
+    /**
+     * Create a frozen instance of {@link SendBatchResponse}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: (partial: Partial<SendBatchResponse> & Required<Omit<SendBatchResponse, never>>) => SendBatchResponse;
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Partial<SendBatchResponse>;
+}>;
 export type SendOnchainFeeQuote = {
     id: string;
     expiresAt: bigint;
@@ -6684,25 +7118,180 @@ export declare const UnfreezeIssuerTokenResponse: Readonly<{
     defaults: () => Partial<UnfreezeIssuerTokenResponse>;
 }>;
 /**
- * Request to unregister an existing webhook.
+ * A leaf selected for exit, with its value.
  */
-export type UnregisterWebhookRequest = {
+export type UnilateralExitLeaf = {
+    leafId: string;
     /**
-     * The unique identifier of the webhook to unregister.
+     * The leaf's value in satoshis.
      */
-    webhookId: string;
+    value: bigint;
 };
 /**
- * Generated factory for {@link UnregisterWebhookRequest} record objects.
+ * Generated factory for {@link UnilateralExitLeaf} record objects.
  */
-export declare const UnregisterWebhookRequest: Readonly<{
+export declare const UnilateralExitLeaf: Readonly<{
     /**
-     * Create a frozen instance of {@link UnregisterWebhookRequest}, with defaults specified
+     * Create a frozen instance of {@link UnilateralExitLeaf}, with defaults specified
      * in Rust, in the {@link breez_sdk_spark} crate.
      */
-    create: (partial: Partial<UnregisterWebhookRequest> & Required<Omit<UnregisterWebhookRequest, never>>) => UnregisterWebhookRequest;
+    create: (partial: Partial<UnilateralExitLeaf> & Required<Omit<UnilateralExitLeaf, never>>) => UnilateralExitLeaf;
     /**
-     * Create a frozen instance of {@link UnregisterWebhookRequest}, with defaults specified
+     * Create a frozen instance of {@link UnilateralExitLeaf}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: (partial: Partial<UnilateralExitLeaf> & Required<Omit<UnilateralExitLeaf, never>>) => UnilateralExitLeaf;
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Partial<UnilateralExitLeaf>;
+}>;
+/**
+ * Request for `unilateral_exit`: a `prepare_unilateral_exit` quote plus the
+ * funding UTXOs that pay its fees. The signer is passed separately (it is not a
+ * plain data value).
+ */
+export type UnilateralExitRequest = {
+    /**
+     * The quote returned by `prepare_unilateral_exit`, naming the leaves to exit.
+     */
+    prepared: PrepareUnilateralExitResponse;
+    /**
+     * The funding UTXOs that pay the exit's on-chain fees, meeting the quote's
+     * `single_utxo_funding_sat` (one UTXO) or `per_branch_funding` (one per branch).
+     */
+    fundingInputs: Array<CpfpInput>;
+};
+/**
+ * Generated factory for {@link UnilateralExitRequest} record objects.
+ */
+export declare const UnilateralExitRequest: Readonly<{
+    /**
+     * Create a frozen instance of {@link UnilateralExitRequest}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create: (partial: Partial<UnilateralExitRequest> & Required<Omit<UnilateralExitRequest, never>>) => UnilateralExitRequest;
+    /**
+     * Create a frozen instance of {@link UnilateralExitRequest}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: (partial: Partial<UnilateralExitRequest> & Required<Omit<UnilateralExitRequest, never>>) => UnilateralExitRequest;
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Partial<UnilateralExitRequest>;
+}>;
+/**
+ * Result of `unilateral_exit`: a cost summary plus the complete, signed exit
+ * path.
+ */
+export type UnilateralExitResponse = {
+    /**
+     * Total value of the selected leaves, in satoshis.
+     */
+    recoverableValueSat: bigint;
+    /**
+     * The actual total on-chain fee the returned transactions pay at the
+     * requested rate, in satoshis. A resumed or partially-confirmed exit pays
+     * less because already-confirmed steps are not rebuilt.
+     */
+    totalFeeSat: bigint;
+    leaves: Array<UnilateralExitLeaf>;
+    /**
+     * The full signed transaction set, in valid topological (broadcast) order
+     * with shared ancestors appearing once and the sweep last.
+     */
+    transactions: Array<UnilateralExitTransaction>;
+};
+/**
+ * Generated factory for {@link UnilateralExitResponse} record objects.
+ */
+export declare const UnilateralExitResponse: Readonly<{
+    /**
+     * Create a frozen instance of {@link UnilateralExitResponse}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create: (partial: Partial<UnilateralExitResponse> & Required<Omit<UnilateralExitResponse, never>>) => UnilateralExitResponse;
+    /**
+     * Create a frozen instance of {@link UnilateralExitResponse}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: (partial: Partial<UnilateralExitResponse> & Required<Omit<UnilateralExitResponse, never>>) => UnilateralExitResponse;
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Partial<UnilateralExitResponse>;
+}>;
+/**
+ * One transaction in the unilateral exit path, with everything needed to
+ * order and broadcast it.
+ */
+export type UnilateralExitTransaction = {
+    kind: UnilateralExitTxKind;
+    /**
+     * The tree node this transaction belongs to. Unset for the fan-out and the
+     * sweep.
+     */
+    nodeId: string | undefined;
+    txid: string;
+    txHex: string;
+    /**
+     * The signed CPFP child to broadcast alongside `tx_hex` as a package.
+     * Unset for the fan-out and the sweep (no anchor to bump) and for a
+     * `Confirmed` step (its CPFP is already on-chain).
+     */
+    cpfpTxHex: string | undefined;
+    /**
+     * Relative CSV timelock, in blocks, that must mature on the spent input
+     * before this transaction can confirm. Unset when there is no timelock.
+     */
+    csvTimelockBlocks: /*u32*/ number | undefined;
+    /**
+     * Txids of other entries in this list that must be confirmed before this
+     * one can be broadcast.
+     */
+    dependsOn: Array<string>;
+    status: ConfirmationStatus;
+};
+/**
+ * Generated factory for {@link UnilateralExitTransaction} record objects.
+ */
+export declare const UnilateralExitTransaction: Readonly<{
+    /**
+     * Create a frozen instance of {@link UnilateralExitTransaction}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create: (partial: Partial<UnilateralExitTransaction> & Required<Omit<UnilateralExitTransaction, never>>) => UnilateralExitTransaction;
+    /**
+     * Create a frozen instance of {@link UnilateralExitTransaction}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: (partial: Partial<UnilateralExitTransaction> & Required<Omit<UnilateralExitTransaction, never>>) => UnilateralExitTransaction;
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Partial<UnilateralExitTransaction>;
+}>;
+/**
+ * Request to unregister an existing webhook.
+ */
+export type UnregisterWebhookRequest = {
+    /**
+     * The unique identifier of the webhook to unregister.
+     */
+    webhookId: string;
+};
+/**
+ * Generated factory for {@link UnregisterWebhookRequest} record objects.
+ */
+export declare const UnregisterWebhookRequest: Readonly<{
+    /**
+     * Create a frozen instance of {@link UnregisterWebhookRequest}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create: (partial: Partial<UnregisterWebhookRequest> & Required<Omit<UnregisterWebhookRequest, never>>) => UnregisterWebhookRequest;
+    /**
+     * Create a frozen instance of {@link UnregisterWebhookRequest}, with defaults specified
      * in Rust, in the {@link breez_sdk_spark} crate.
      */
     new: (partial: Partial<UnregisterWebhookRequest> & Required<Omit<UnregisterWebhookRequest, never>>) => UnregisterWebhookRequest;
@@ -6771,6 +7360,14 @@ export type UpdateUserSettingsRequest = {
      * Update the active stable balance token. `None` means no change.
      */
     stableBalanceActiveLabel: StableBalanceActiveLabel | undefined;
+    /**
+     * Designate or remove the wallet's master identity, a second public key
+     * the Spark operators accept as a reader of this wallet's balance and
+     * history while `spark_private_mode_enabled` is set. The master identity
+     * can only read: payments still require the owner's keys. `None` means no
+     * change.
+     */
+    sparkMasterIdentityPublicKey: SparkMasterIdentityPublicKey | undefined;
 };
 /**
  * Generated factory for {@link UpdateUserSettingsRequest} record objects.
@@ -6780,12 +7377,12 @@ export declare const UpdateUserSettingsRequest: Readonly<{
      * Create a frozen instance of {@link UpdateUserSettingsRequest}, with defaults specified
      * in Rust, in the {@link breez_sdk_spark} crate.
      */
-    create: (partial: Partial<UpdateUserSettingsRequest> & Required<Omit<UpdateUserSettingsRequest, "stableBalanceActiveLabel">>) => UpdateUserSettingsRequest;
+    create: (partial: Partial<UpdateUserSettingsRequest> & Required<Omit<UpdateUserSettingsRequest, "stableBalanceActiveLabel" | "sparkMasterIdentityPublicKey">>) => UpdateUserSettingsRequest;
     /**
      * Create a frozen instance of {@link UpdateUserSettingsRequest}, with defaults specified
      * in Rust, in the {@link breez_sdk_spark} crate.
      */
-    new: (partial: Partial<UpdateUserSettingsRequest> & Required<Omit<UpdateUserSettingsRequest, "stableBalanceActiveLabel">>) => UpdateUserSettingsRequest;
+    new: (partial: Partial<UpdateUserSettingsRequest> & Required<Omit<UpdateUserSettingsRequest, "stableBalanceActiveLabel" | "sparkMasterIdentityPublicKey">>) => UpdateUserSettingsRequest;
     /**
      * Defaults specified in the {@link breez_sdk_spark} crate.
      */
@@ -6832,6 +7429,11 @@ export type UserSettings = {
      * The label of the currently active stable balance token, or `None` if deactivated.
      */
     stableBalanceActiveLabel: string | undefined;
+    /**
+     * The hex encoded public key designated as this wallet's master identity
+     * key, or `None` if none is designated.
+     */
+    sparkMasterIdentityPublicKey: string | undefined;
 };
 /**
  * Generated factory for {@link UserSettings} record objects.
@@ -7482,6 +8084,98 @@ export declare const AutoOptimizationEvent: Readonly<{
     };
 }>;
 export type AutoOptimizationEvent = InstanceType<(typeof AutoOptimizationEvent)[keyof Omit<typeof AutoOptimizationEvent, 'instanceOf'>]>;
+export declare enum BatchDestination_Tags {
+    SparkAddress = "SparkAddress",
+    SparkInvoice = "SparkInvoice"
+}
+/**
+ * Where a batch recipient is paid, once prepare has decoded its payment request.
+ */
+export declare const BatchDestination: Readonly<{
+    instanceOf: (obj: any) => obj is BatchDestination;
+    SparkAddress: {
+        new (inner: {
+            address: string;
+        }): {
+            readonly tag: BatchDestination_Tags.SparkAddress;
+            readonly inner: Readonly<{
+                address: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BatchDestination";
+        };
+        "new"(inner: {
+            address: string;
+        }): {
+            readonly tag: BatchDestination_Tags.SparkAddress;
+            readonly inner: Readonly<{
+                address: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BatchDestination";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: BatchDestination_Tags.SparkAddress;
+            readonly inner: Readonly<{
+                address: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BatchDestination";
+        };
+    };
+    SparkInvoice: {
+        new (inner: {
+            invoiceDetails: SparkInvoiceDetails;
+        }): {
+            readonly tag: BatchDestination_Tags.SparkInvoice;
+            readonly inner: Readonly<{
+                invoiceDetails: SparkInvoiceDetails;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BatchDestination";
+        };
+        "new"(inner: {
+            invoiceDetails: SparkInvoiceDetails;
+        }): {
+            readonly tag: BatchDestination_Tags.SparkInvoice;
+            readonly inner: Readonly<{
+                invoiceDetails: SparkInvoiceDetails;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BatchDestination";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: BatchDestination_Tags.SparkInvoice;
+            readonly inner: Readonly<{
+                invoiceDetails: SparkInvoiceDetails;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BatchDestination";
+        };
+    };
+}>;
+/**
+ * Where a batch recipient is paid, once prepare has decoded its payment request.
+ */
+export type BatchDestination = InstanceType<(typeof BatchDestination)[keyof Omit<typeof BatchDestination, 'instanceOf'>]>;
 export declare enum BitcoinNetwork {
     /**
      * Mainnet
@@ -7932,6 +8626,24 @@ export declare const ChainServiceError: Readonly<{
     };
 }>;
 export type ChainServiceError = InstanceType<(typeof ChainServiceError)[keyof Omit<typeof ChainServiceError, 'instanceOf'>]>;
+/**
+ * Whether a transaction in the exit path is already on-chain.
+ */
+export declare enum ConfirmationStatus {
+    /**
+     * This transaction is confirmed in a block. It needs no action.
+     */
+    Confirmed = 0,
+    /**
+     * This transaction is not yet confirmed. Mempool state is not consulted.
+     */
+    Unconfirmed = 1,
+    /**
+     * The on-chain status could not be determined (the chain service errored).
+     * Broadcasting may fail if a conflicting transaction already landed.
+     */
+    Unverified = 2
+}
 export declare enum ConversionChain_Tags {
     Spark = "Spark",
     Lightning = "Lightning",
@@ -8715,111 +9427,404 @@ export declare const ConversionPurpose: Readonly<{
             readonly [uniffiTypeNameSymbol]: "ConversionPurpose";
         };
     };
-}>;
-/**
- * The purpose of the conversion, which is used to provide context for the conversion
- * if its related to an ongoing payment or a self-transfer.
- */
-export type ConversionPurpose = InstanceType<(typeof ConversionPurpose)[keyof Omit<typeof ConversionPurpose, 'instanceOf'>]>;
-/**
- * The status of the conversion
- */
-export declare enum ConversionStatus {
-    /**
-     * Conversion is in-flight (queued or started, not yet completed)
-     */
-    Pending = 0,
-    /**
-     * The conversion was successful
-     */
-    Completed = 1,
-    /**
-     * The conversion failed (e.g., the initial send payment failed)
-     */
-    Failed = 2,
-    /**
-     * The conversion failed and no refund was made yet, which requires action by the SDK to
-     * perform the refund. This can happen if there was a failure during the conversion process.
-     */
-    RefundNeeded = 3,
-    /**
-     * The conversion failed and a refund was made
-     */
-    Refunded = 4
-}
-export declare enum ConversionType_Tags {
-    FromBitcoin = "FromBitcoin",
-    ToBitcoin = "ToBitcoin"
-}
-export declare const ConversionType: Readonly<{
-    instanceOf: (obj: any) => obj is ConversionType;
-    FromBitcoin: {
-        new (): {
-            readonly tag: ConversionType_Tags.FromBitcoin;
+}>;
+/**
+ * The purpose of the conversion, which is used to provide context for the conversion
+ * if its related to an ongoing payment or a self-transfer.
+ */
+export type ConversionPurpose = InstanceType<(typeof ConversionPurpose)[keyof Omit<typeof ConversionPurpose, 'instanceOf'>]>;
+/**
+ * The status of the conversion
+ */
+export declare enum ConversionStatus {
+    /**
+     * Conversion is in-flight (queued or started, not yet completed)
+     */
+    Pending = 0,
+    /**
+     * The conversion was successful
+     */
+    Completed = 1,
+    /**
+     * The conversion failed (e.g., the initial send payment failed)
+     */
+    Failed = 2,
+    /**
+     * The conversion failed and no refund was made yet, which requires action by the SDK to
+     * perform the refund. This can happen if there was a failure during the conversion process.
+     */
+    RefundNeeded = 3,
+    /**
+     * The conversion failed and a refund was made
+     */
+    Refunded = 4
+}
+export declare enum ConversionType_Tags {
+    FromBitcoin = "FromBitcoin",
+    ToBitcoin = "ToBitcoin"
+}
+export declare const ConversionType: Readonly<{
+    instanceOf: (obj: any) => obj is ConversionType;
+    FromBitcoin: {
+        new (): {
+            readonly tag: ConversionType_Tags.FromBitcoin;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ConversionType";
+        };
+        "new"(): {
+            readonly tag: ConversionType_Tags.FromBitcoin;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ConversionType";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ConversionType_Tags.FromBitcoin;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ConversionType";
+        };
+    };
+    ToBitcoin: {
+        new (inner: {
+            fromTokenIdentifier: string;
+        }): {
+            readonly tag: ConversionType_Tags.ToBitcoin;
+            readonly inner: Readonly<{
+                fromTokenIdentifier: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ConversionType";
+        };
+        "new"(inner: {
+            fromTokenIdentifier: string;
+        }): {
+            readonly tag: ConversionType_Tags.ToBitcoin;
+            readonly inner: Readonly<{
+                fromTokenIdentifier: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ConversionType";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ConversionType_Tags.ToBitcoin;
+            readonly inner: Readonly<{
+                fromTokenIdentifier: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ConversionType";
+        };
+    };
+}>;
+export type ConversionType = InstanceType<(typeof ConversionType)[keyof Omit<typeof ConversionType, 'instanceOf'>]>;
+export declare enum CpfpFundingKind_Tags {
+    P2wpkh = "P2wpkh",
+    P2tr = "P2tr",
+    Custom = "Custom"
+}
+/**
+ * The kind of UTXO that will fund an exit's fees.
+ */
+export declare const CpfpFundingKind: Readonly<{
+    instanceOf: (obj: any) => obj is CpfpFundingKind;
+    P2wpkh: {
+        new (): {
+            readonly tag: CpfpFundingKind_Tags.P2wpkh;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CpfpFundingKind";
+        };
+        "new"(): {
+            readonly tag: CpfpFundingKind_Tags.P2wpkh;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CpfpFundingKind";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: CpfpFundingKind_Tags.P2wpkh;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CpfpFundingKind";
+        };
+    };
+    P2tr: {
+        new (): {
+            readonly tag: CpfpFundingKind_Tags.P2tr;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CpfpFundingKind";
+        };
+        "new"(): {
+            readonly tag: CpfpFundingKind_Tags.P2tr;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CpfpFundingKind";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: CpfpFundingKind_Tags.P2tr;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CpfpFundingKind";
+        };
+    };
+    Custom: {
+        new (inner: {
+            scriptPubkeyHex: string;
+            signedInputWeight: bigint;
+        }): {
+            readonly tag: CpfpFundingKind_Tags.Custom;
+            readonly inner: Readonly<{
+                scriptPubkeyHex: string;
+                signedInputWeight: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CpfpFundingKind";
+        };
+        "new"(inner: {
+            scriptPubkeyHex: string;
+            signedInputWeight: bigint;
+        }): {
+            readonly tag: CpfpFundingKind_Tags.Custom;
+            readonly inner: Readonly<{
+                scriptPubkeyHex: string;
+                signedInputWeight: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CpfpFundingKind";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: CpfpFundingKind_Tags.Custom;
+            readonly inner: Readonly<{
+                scriptPubkeyHex: string;
+                signedInputWeight: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CpfpFundingKind";
+        };
+    };
+}>;
+/**
+ * The kind of UTXO that will fund an exit's fees.
+ */
+export type CpfpFundingKind = InstanceType<(typeof CpfpFundingKind)[keyof Omit<typeof CpfpFundingKind, 'instanceOf'>]>;
+export declare enum CpfpInput_Tags {
+    P2wpkh = "P2wpkh",
+    P2tr = "P2tr",
+    Custom = "Custom"
+}
+/**
+ * A funding UTXO that pays the on-chain fees of a unilateral exit.
+ */
+export declare const CpfpInput: Readonly<{
+    instanceOf: (obj: any) => obj is CpfpInput;
+    P2wpkh: {
+        new (inner: {
+            txid: string;
+            vout: number;
+            value: bigint;
+            pubkey: string;
+        }): {
+            readonly tag: CpfpInput_Tags.P2wpkh;
+            readonly inner: Readonly<{
+                txid: string;
+                vout: number;
+                value: bigint;
+                pubkey: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CpfpInput";
+        };
+        "new"(inner: {
+            txid: string;
+            vout: number;
+            value: bigint;
+            pubkey: string;
+        }): {
+            readonly tag: CpfpInput_Tags.P2wpkh;
+            readonly inner: Readonly<{
+                txid: string;
+                vout: number;
+                value: bigint;
+                pubkey: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CpfpInput";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: CpfpInput_Tags.P2wpkh;
+            readonly inner: Readonly<{
+                txid: string;
+                vout: number;
+                value: bigint;
+                pubkey: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "CpfpInput";
+        };
+    };
+    P2tr: {
+        new (inner: {
+            txid: string;
+            vout: number;
+            value: bigint;
+            pubkey: string;
+        }): {
+            readonly tag: CpfpInput_Tags.P2tr;
+            readonly inner: Readonly<{
+                txid: string;
+                vout: number;
+                value: bigint;
+                pubkey: string;
+            }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "ConversionType";
+            readonly [uniffiTypeNameSymbol]: "CpfpInput";
         };
-        "new"(): {
-            readonly tag: ConversionType_Tags.FromBitcoin;
+        "new"(inner: {
+            txid: string;
+            vout: number;
+            value: bigint;
+            pubkey: string;
+        }): {
+            readonly tag: CpfpInput_Tags.P2tr;
+            readonly inner: Readonly<{
+                txid: string;
+                vout: number;
+                value: bigint;
+                pubkey: string;
+            }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "ConversionType";
+            readonly [uniffiTypeNameSymbol]: "CpfpInput";
         };
         instanceOf(obj: any): obj is {
-            readonly tag: ConversionType_Tags.FromBitcoin;
+            readonly tag: CpfpInput_Tags.P2tr;
+            readonly inner: Readonly<{
+                txid: string;
+                vout: number;
+                value: bigint;
+                pubkey: string;
+            }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "ConversionType";
+            readonly [uniffiTypeNameSymbol]: "CpfpInput";
         };
     };
-    ToBitcoin: {
+    Custom: {
         new (inner: {
-            fromTokenIdentifier: string;
+            txid: string;
+            vout: number;
+            value: bigint;
+            scriptPubkeyHex: string;
+            signedInputWeight: bigint;
         }): {
-            readonly tag: ConversionType_Tags.ToBitcoin;
+            readonly tag: CpfpInput_Tags.Custom;
             readonly inner: Readonly<{
-                fromTokenIdentifier: string;
+                txid: string;
+                vout: number;
+                value: bigint;
+                scriptPubkeyHex: string;
+                signedInputWeight: bigint;
             }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "ConversionType";
+            readonly [uniffiTypeNameSymbol]: "CpfpInput";
         };
         "new"(inner: {
-            fromTokenIdentifier: string;
+            txid: string;
+            vout: number;
+            value: bigint;
+            scriptPubkeyHex: string;
+            signedInputWeight: bigint;
         }): {
-            readonly tag: ConversionType_Tags.ToBitcoin;
+            readonly tag: CpfpInput_Tags.Custom;
             readonly inner: Readonly<{
-                fromTokenIdentifier: string;
+                txid: string;
+                vout: number;
+                value: bigint;
+                scriptPubkeyHex: string;
+                signedInputWeight: bigint;
             }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "ConversionType";
+            readonly [uniffiTypeNameSymbol]: "CpfpInput";
         };
         instanceOf(obj: any): obj is {
-            readonly tag: ConversionType_Tags.ToBitcoin;
+            readonly tag: CpfpInput_Tags.Custom;
             readonly inner: Readonly<{
-                fromTokenIdentifier: string;
+                txid: string;
+                vout: number;
+                value: bigint;
+                scriptPubkeyHex: string;
+                signedInputWeight: bigint;
             }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "ConversionType";
+            readonly [uniffiTypeNameSymbol]: "CpfpInput";
         };
     };
 }>;
-export type ConversionType = InstanceType<(typeof ConversionType)[keyof Omit<typeof ConversionType, 'instanceOf'>]>;
+/**
+ * A funding UTXO that pays the on-chain fees of a unilateral exit.
+ */
+export type CpfpInput = InstanceType<(typeof CpfpInput)[keyof Omit<typeof CpfpInput, 'instanceOf'>]>;
 export declare enum CrossChainAddressFamily {
     Evm = 0,
     Solana = 1,
@@ -9412,6 +10417,85 @@ export declare enum ErrorKind {
      */
     Internal = 8
 }
+export declare enum ExitLeafSelection_Tags {
+    Auto = "Auto",
+    Specific = "Specific"
+}
+/**
+ * Which leaves to exit.
+ */
+export declare const ExitLeafSelection: Readonly<{
+    instanceOf: (obj: any) => obj is ExitLeafSelection;
+    Auto: {
+        new (): {
+            readonly tag: ExitLeafSelection_Tags.Auto;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ExitLeafSelection";
+        };
+        "new"(): {
+            readonly tag: ExitLeafSelection_Tags.Auto;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ExitLeafSelection";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ExitLeafSelection_Tags.Auto;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ExitLeafSelection";
+        };
+    };
+    Specific: {
+        new (inner: {
+            leafIds: Array<string>;
+        }): {
+            readonly tag: ExitLeafSelection_Tags.Specific;
+            readonly inner: Readonly<{
+                leafIds: Array<string>;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ExitLeafSelection";
+        };
+        "new"(inner: {
+            leafIds: Array<string>;
+        }): {
+            readonly tag: ExitLeafSelection_Tags.Specific;
+            readonly inner: Readonly<{
+                leafIds: Array<string>;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ExitLeafSelection";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ExitLeafSelection_Tags.Specific;
+            readonly inner: Readonly<{
+                leafIds: Array<string>;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ExitLeafSelection";
+        };
+    };
+}>;
+/**
+ * Which leaves to exit.
+ */
+export type ExitLeafSelection = InstanceType<(typeof ExitLeafSelection)[keyof Omit<typeof ExitLeafSelection, 'instanceOf'>]>;
 export declare enum ExternalFrostDerivation_Tags {
     SigningLeaf = "SigningLeaf",
     StaticDeposit = "StaticDeposit",
@@ -10488,6 +11572,95 @@ export declare const OptimizationOutcome: Readonly<{
  * ```
  */
 export type OptimizationOutcome = InstanceType<(typeof OptimizationOutcome)[keyof Omit<typeof OptimizationOutcome, 'instanceOf'>]>;
+export declare enum Outspend_Tags {
+    Unspent = "Unspent",
+    Spent = "Spent"
+}
+/**
+ * The spend status of a transaction output.
+ */
+export declare const Outspend: Readonly<{
+    instanceOf: (obj: any) => obj is Outspend;
+    Unspent: {
+        new (): {
+            readonly tag: Outspend_Tags.Unspent;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "Outspend";
+        };
+        "new"(): {
+            readonly tag: Outspend_Tags.Unspent;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "Outspend";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: Outspend_Tags.Unspent;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "Outspend";
+        };
+    };
+    Spent: {
+        new (inner: {
+            txid: string;
+            vin: number;
+            status: TxStatus;
+        }): {
+            readonly tag: Outspend_Tags.Spent;
+            readonly inner: Readonly<{
+                txid: string;
+                vin: number;
+                status: TxStatus;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "Outspend";
+        };
+        "new"(inner: {
+            txid: string;
+            vin: number;
+            status: TxStatus;
+        }): {
+            readonly tag: Outspend_Tags.Spent;
+            readonly inner: Readonly<{
+                txid: string;
+                vin: number;
+                status: TxStatus;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "Outspend";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: Outspend_Tags.Spent;
+            readonly inner: Readonly<{
+                txid: string;
+                vin: number;
+                status: TxStatus;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "Outspend";
+        };
+    };
+}>;
+/**
+ * The spend status of a transaction output.
+ */
+export type Outspend = InstanceType<(typeof Outspend)[keyof Omit<typeof Outspend, 'instanceOf'>]>;
 export declare enum PasskeyAvailability_Tags {
     Available = "Available",
     PrfUnsupported = "PrfUnsupported",
@@ -10654,6 +11827,7 @@ export declare enum PasskeyError_Tags {
     InvalidPrfOutput = "InvalidPrfOutput",
     MnemonicError = "MnemonicError",
     InvalidSalt = "InvalidSalt",
+    CreatedButNotDerived = "CreatedButNotDerived",
     Generic = "Generic"
 }
 /**
@@ -11057,7 +12231,78 @@ export declare const PasskeyError: Readonly<{
             cause?: unknown;
         };
         hasInner(obj: any): obj is {
-            readonly tag: PasskeyError_Tags.InvalidPrfOutput;
+            readonly tag: PasskeyError_Tags.InvalidPrfOutput;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "PasskeyError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: PasskeyError_Tags.InvalidPrfOutput;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "PasskeyError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<[string]>;
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+        stackTraceLimit: number;
+    };
+    MnemonicError: {
+        new (v0: string): {
+            readonly tag: PasskeyError_Tags.MnemonicError;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "PasskeyError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(v0: string): {
+            readonly tag: PasskeyError_Tags.MnemonicError;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "PasskeyError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: PasskeyError_Tags.MnemonicError;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "PasskeyError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: PasskeyError_Tags.MnemonicError;
             readonly inner: Readonly<[string]>;
             /**
              * @private
@@ -11070,7 +12315,7 @@ export declare const PasskeyError: Readonly<{
             cause?: unknown;
         };
         getInner(obj: {
-            readonly tag: PasskeyError_Tags.InvalidPrfOutput;
+            readonly tag: PasskeyError_Tags.MnemonicError;
             readonly inner: Readonly<[string]>;
             /**
              * @private
@@ -11087,9 +12332,9 @@ export declare const PasskeyError: Readonly<{
         prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
         stackTraceLimit: number;
     };
-    MnemonicError: {
+    InvalidSalt: {
         new (v0: string): {
-            readonly tag: PasskeyError_Tags.MnemonicError;
+            readonly tag: PasskeyError_Tags.InvalidSalt;
             readonly inner: Readonly<[string]>;
             /**
              * @private
@@ -11102,7 +12347,7 @@ export declare const PasskeyError: Readonly<{
             cause?: unknown;
         };
         "new"(v0: string): {
-            readonly tag: PasskeyError_Tags.MnemonicError;
+            readonly tag: PasskeyError_Tags.InvalidSalt;
             readonly inner: Readonly<[string]>;
             /**
              * @private
@@ -11115,7 +12360,7 @@ export declare const PasskeyError: Readonly<{
             cause?: unknown;
         };
         instanceOf(obj: any): obj is {
-            readonly tag: PasskeyError_Tags.MnemonicError;
+            readonly tag: PasskeyError_Tags.InvalidSalt;
             readonly inner: Readonly<[string]>;
             /**
              * @private
@@ -11128,7 +12373,7 @@ export declare const PasskeyError: Readonly<{
             cause?: unknown;
         };
         hasInner(obj: any): obj is {
-            readonly tag: PasskeyError_Tags.MnemonicError;
+            readonly tag: PasskeyError_Tags.InvalidSalt;
             readonly inner: Readonly<[string]>;
             /**
              * @private
@@ -11141,7 +12386,7 @@ export declare const PasskeyError: Readonly<{
             cause?: unknown;
         };
         getInner(obj: {
-            readonly tag: PasskeyError_Tags.MnemonicError;
+            readonly tag: PasskeyError_Tags.InvalidSalt;
             readonly inner: Readonly<[string]>;
             /**
              * @private
@@ -11158,10 +12403,16 @@ export declare const PasskeyError: Readonly<{
         prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
         stackTraceLimit: number;
     };
-    InvalidSalt: {
-        new (v0: string): {
-            readonly tag: PasskeyError_Tags.InvalidSalt;
-            readonly inner: Readonly<[string]>;
+    CreatedButNotDerived: {
+        new (inner: {
+            credentialId: ArrayBuffer;
+            source: PrfProviderError;
+        }): {
+            readonly tag: PasskeyError_Tags.CreatedButNotDerived;
+            readonly inner: Readonly<{
+                credentialId: ArrayBuffer;
+                source: PrfProviderError;
+            }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
@@ -11172,9 +12423,15 @@ export declare const PasskeyError: Readonly<{
             stack?: string;
             cause?: unknown;
         };
-        "new"(v0: string): {
-            readonly tag: PasskeyError_Tags.InvalidSalt;
-            readonly inner: Readonly<[string]>;
+        "new"(inner: {
+            credentialId: ArrayBuffer;
+            source: PrfProviderError;
+        }): {
+            readonly tag: PasskeyError_Tags.CreatedButNotDerived;
+            readonly inner: Readonly<{
+                credentialId: ArrayBuffer;
+                source: PrfProviderError;
+            }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
@@ -11186,8 +12443,11 @@ export declare const PasskeyError: Readonly<{
             cause?: unknown;
         };
         instanceOf(obj: any): obj is {
-            readonly tag: PasskeyError_Tags.InvalidSalt;
-            readonly inner: Readonly<[string]>;
+            readonly tag: PasskeyError_Tags.CreatedButNotDerived;
+            readonly inner: Readonly<{
+                credentialId: ArrayBuffer;
+                source: PrfProviderError;
+            }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
@@ -11199,8 +12459,11 @@ export declare const PasskeyError: Readonly<{
             cause?: unknown;
         };
         hasInner(obj: any): obj is {
-            readonly tag: PasskeyError_Tags.InvalidSalt;
-            readonly inner: Readonly<[string]>;
+            readonly tag: PasskeyError_Tags.CreatedButNotDerived;
+            readonly inner: Readonly<{
+                credentialId: ArrayBuffer;
+                source: PrfProviderError;
+            }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
@@ -11212,8 +12475,11 @@ export declare const PasskeyError: Readonly<{
             cause?: unknown;
         };
         getInner(obj: {
-            readonly tag: PasskeyError_Tags.InvalidSalt;
-            readonly inner: Readonly<[string]>;
+            readonly tag: PasskeyError_Tags.CreatedButNotDerived;
+            readonly inner: Readonly<{
+                credentialId: ArrayBuffer;
+                source: PrfProviderError;
+            }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
@@ -11223,7 +12489,10 @@ export declare const PasskeyError: Readonly<{
             message: string;
             stack?: string;
             cause?: unknown;
-        }): Readonly<[string]>;
+        }): Readonly<{
+            credentialId: ArrayBuffer;
+            source: PrfProviderError;
+        }>;
         isError(error: unknown): error is Error;
         captureStackTrace(targetObject: object, constructorOpt?: Function): void;
         prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
@@ -13008,7 +14277,8 @@ export declare const PublishSignedLnurlPayResponse: Readonly<{
 export type PublishSignedLnurlPayResponse = InstanceType<(typeof PublishSignedLnurlPayResponse)[keyof Omit<typeof PublishSignedLnurlPayResponse, 'instanceOf'>]>;
 export declare enum PublishSignedTransferPackageResponse_Tags {
     SwapCompleted = "SwapCompleted",
-    PaymentSent = "PaymentSent"
+    PaymentSent = "PaymentSent",
+    PaymentsSent = "PaymentsSent"
 }
 export declare const PublishSignedTransferPackageResponse: Readonly<{
     instanceOf: (obj: any) => obj is PublishSignedTransferPackageResponse;
@@ -13077,6 +14347,45 @@ export declare const PublishSignedTransferPackageResponse: Readonly<{
             readonly [uniffiTypeNameSymbol]: "PublishSignedTransferPackageResponse";
         };
     };
+    PaymentsSent: {
+        new (inner: {
+            payments: Array<Payment>;
+        }): {
+            readonly tag: PublishSignedTransferPackageResponse_Tags.PaymentsSent;
+            readonly inner: Readonly<{
+                payments: Array<Payment>;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "PublishSignedTransferPackageResponse";
+        };
+        "new"(inner: {
+            payments: Array<Payment>;
+        }): {
+            readonly tag: PublishSignedTransferPackageResponse_Tags.PaymentsSent;
+            readonly inner: Readonly<{
+                payments: Array<Payment>;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "PublishSignedTransferPackageResponse";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: PublishSignedTransferPackageResponse_Tags.PaymentsSent;
+            readonly inner: Readonly<{
+                payments: Array<Payment>;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "PublishSignedTransferPackageResponse";
+        };
+    };
 }>;
 export type PublishSignedTransferPackageResponse = InstanceType<(typeof PublishSignedTransferPackageResponse)[keyof Omit<typeof PublishSignedTransferPackageResponse, 'instanceOf'>]>;
 export declare enum ReceivePaymentMethod_Tags {
@@ -13323,6 +14632,8 @@ export declare enum SdkError_Tags {
     Signer = "Signer",
     OptimizationAlreadyRunning = "OptimizationAlreadyRunning",
     OptimizationCancelled = "OptimizationCancelled",
+    InsufficientCpfpFunds = "InsufficientCpfpFunds",
+    FundingUtxoConflict = "FundingUtxoConflict",
     Generic = "Generic"
 }
 /**
@@ -13402,8 +14713,16 @@ export declare const SdkError: Readonly<{
         stackTraceLimit: number;
     };
     InsufficientFunds: {
-        new (): {
+        new (inner: {
+            /**
+             * The token that cannot cover the payment. Unset when the shortfall is
+             * in sats or when no single token can be named.
+             */ tokenIdentifier: string | undefined;
+        }): {
             readonly tag: SdkError_Tags.InsufficientFunds;
+            readonly inner: Readonly<{
+                tokenIdentifier: string | undefined;
+            }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
@@ -13414,8 +14733,16 @@ export declare const SdkError: Readonly<{
             stack?: string;
             cause?: unknown;
         };
-        "new"(): {
+        "new"(inner: {
+            /**
+             * The token that cannot cover the payment. Unset when the shortfall is
+             * in sats or when no single token can be named.
+             */ tokenIdentifier: string | undefined;
+        }): {
             readonly tag: SdkError_Tags.InsufficientFunds;
+            readonly inner: Readonly<{
+                tokenIdentifier: string | undefined;
+            }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
@@ -13428,6 +14755,9 @@ export declare const SdkError: Readonly<{
         };
         instanceOf(obj: any): obj is {
             readonly tag: SdkError_Tags.InsufficientFunds;
+            readonly inner: Readonly<{
+                tokenIdentifier: string | undefined;
+            }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
@@ -13440,6 +14770,9 @@ export declare const SdkError: Readonly<{
         };
         hasInner(obj: any): obj is {
             readonly tag: SdkError_Tags.InsufficientFunds;
+            readonly inner: Readonly<{
+                tokenIdentifier: string | undefined;
+            }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
@@ -13450,6 +14783,23 @@ export declare const SdkError: Readonly<{
             stack?: string;
             cause?: unknown;
         };
+        getInner(obj: {
+            readonly tag: SdkError_Tags.InsufficientFunds;
+            readonly inner: Readonly<{
+                tokenIdentifier: string | undefined;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            tokenIdentifier: string | undefined;
+        }>;
         isError(error: unknown): error is Error;
         captureStackTrace(targetObject: object, constructorOpt?: Function): void;
         prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
@@ -14233,8 +15583,179 @@ export declare const SdkError: Readonly<{
             stack?: string;
             cause?: unknown;
         };
-        "new"(): {
-            readonly tag: SdkError_Tags.OptimizationCancelled;
+        "new"(): {
+            readonly tag: SdkError_Tags.OptimizationCancelled;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: SdkError_Tags.OptimizationCancelled;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: SdkError_Tags.OptimizationCancelled;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+        stackTraceLimit: number;
+    };
+    InsufficientCpfpFunds: {
+        new (inner: {
+            requiredSat: bigint;
+        }): {
+            readonly tag: SdkError_Tags.InsufficientCpfpFunds;
+            readonly inner: Readonly<{
+                requiredSat: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            requiredSat: bigint;
+        }): {
+            readonly tag: SdkError_Tags.InsufficientCpfpFunds;
+            readonly inner: Readonly<{
+                requiredSat: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: SdkError_Tags.InsufficientCpfpFunds;
+            readonly inner: Readonly<{
+                requiredSat: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: SdkError_Tags.InsufficientCpfpFunds;
+            readonly inner: Readonly<{
+                requiredSat: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: SdkError_Tags.InsufficientCpfpFunds;
+            readonly inner: Readonly<{
+                requiredSat: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            requiredSat: bigint;
+        }>;
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+        stackTraceLimit: number;
+    };
+    FundingUtxoConflict: {
+        new (inner: {
+            txid: string;
+            vout: number;
+        }): {
+            readonly tag: SdkError_Tags.FundingUtxoConflict;
+            readonly inner: Readonly<{
+                txid: string;
+                vout: number;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            txid: string;
+            vout: number;
+        }): {
+            readonly tag: SdkError_Tags.FundingUtxoConflict;
+            readonly inner: Readonly<{
+                txid: string;
+                vout: number;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SdkError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: SdkError_Tags.FundingUtxoConflict;
+            readonly inner: Readonly<{
+                txid: string;
+                vout: number;
+            }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
@@ -14245,8 +15766,12 @@ export declare const SdkError: Readonly<{
             stack?: string;
             cause?: unknown;
         };
-        instanceOf(obj: any): obj is {
-            readonly tag: SdkError_Tags.OptimizationCancelled;
+        hasInner(obj: any): obj is {
+            readonly tag: SdkError_Tags.FundingUtxoConflict;
+            readonly inner: Readonly<{
+                txid: string;
+                vout: number;
+            }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
@@ -14257,8 +15782,12 @@ export declare const SdkError: Readonly<{
             stack?: string;
             cause?: unknown;
         };
-        hasInner(obj: any): obj is {
-            readonly tag: SdkError_Tags.OptimizationCancelled;
+        getInner(obj: {
+            readonly tag: SdkError_Tags.FundingUtxoConflict;
+            readonly inner: Readonly<{
+                txid: string;
+                vout: number;
+            }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
@@ -14268,7 +15797,10 @@ export declare const SdkError: Readonly<{
             message: string;
             stack?: string;
             cause?: unknown;
-        };
+        }): Readonly<{
+            txid: string;
+            vout: number;
+        }>;
         isError(error: unknown): error is Error;
         captureStackTrace(targetObject: object, constructorOpt?: Function): void;
         prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
@@ -16930,6 +18462,85 @@ export declare enum SparkHtlcStatus {
      */
     Returned = 2
 }
+export declare enum SparkMasterIdentityPublicKey_Tags {
+    Set = "Set",
+    Unset = "Unset"
+}
+/**
+ * Specifies how to update the wallet's Spark master identity public key.
+ */
+export declare const SparkMasterIdentityPublicKey: Readonly<{
+    instanceOf: (obj: any) => obj is SparkMasterIdentityPublicKey;
+    Set: {
+        new (inner: {
+            publicKey: string;
+        }): {
+            readonly tag: SparkMasterIdentityPublicKey_Tags.Set;
+            readonly inner: Readonly<{
+                publicKey: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SparkMasterIdentityPublicKey";
+        };
+        "new"(inner: {
+            publicKey: string;
+        }): {
+            readonly tag: SparkMasterIdentityPublicKey_Tags.Set;
+            readonly inner: Readonly<{
+                publicKey: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SparkMasterIdentityPublicKey";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: SparkMasterIdentityPublicKey_Tags.Set;
+            readonly inner: Readonly<{
+                publicKey: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SparkMasterIdentityPublicKey";
+        };
+    };
+    Unset: {
+        new (): {
+            readonly tag: SparkMasterIdentityPublicKey_Tags.Unset;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SparkMasterIdentityPublicKey";
+        };
+        "new"(): {
+            readonly tag: SparkMasterIdentityPublicKey_Tags.Unset;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SparkMasterIdentityPublicKey";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: SparkMasterIdentityPublicKey_Tags.Unset;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SparkMasterIdentityPublicKey";
+        };
+    };
+}>;
+/**
+ * Specifies how to update the wallet's Spark master identity public key.
+ */
+export type SparkMasterIdentityPublicKey = InstanceType<(typeof SparkMasterIdentityPublicKey)[keyof Omit<typeof SparkMasterIdentityPublicKey, 'instanceOf'>]>;
 export declare enum StableBalanceActiveLabel_Tags {
     Set = "Set",
     Unset = "Unset"
@@ -18037,10 +19648,33 @@ export declare const TransferTarget: Readonly<{
     };
 }>;
 export type TransferTarget = InstanceType<(typeof TransferTarget)[keyof Omit<typeof TransferTarget, 'instanceOf'>]>;
+/**
+ * The role of a transaction in the exit path.
+ */
+export declare enum UnilateralExitTxKind {
+    /**
+     * Splits the caller's funding into one output per branch. Present only
+     * when the funding couldn't be matched one-to-one to branches.
+     */
+    FanOut = 0,
+    /**
+     * A tree node transaction (root, intermediate, or leaf node).
+     */
+    Node = 1,
+    /**
+     * A leaf's refund transaction.
+     */
+    Refund = 2,
+    /**
+     * The final transaction sweeping all refund outputs to the destination.
+     */
+    Sweep = 3
+}
 export declare enum UnsignedTransferPackage_Tags {
     Swap = "Swap",
     Transfer = "Transfer",
-    Token = "Token"
+    Token = "Token",
+    TokenBatch = "TokenBatch"
 }
 export declare const UnsignedTransferPackage: Readonly<{
     instanceOf: (obj: any) => obj is UnsignedTransferPackage;
@@ -18224,6 +19858,74 @@ export declare const UnsignedTransferPackage: Readonly<{
             readonly [uniffiTypeNameSymbol]: "UnsignedTransferPackage";
         };
     };
+    TokenBatch: {
+        new (inner: {
+            prepareTokenTransaction: ExternalPrepareTokenTransactionRequest;
+            tokenContext: ArrayBuffer;
+            /**
+             * What the batch debits, per token. A batch spanning tokens has no
+             * single amount to report.
+             */ totals: Array<BatchTotal>;
+            /**
+             * When set, this package re-shapes the wallet's token outputs instead of
+             * sending a payment. Publishing it returns `SwapCompleted`: rebuild the
+             * original send from the same prepare response and submit again.
+             */ isSwap: boolean;
+        }): {
+            readonly tag: UnsignedTransferPackage_Tags.TokenBatch;
+            readonly inner: Readonly<{
+                prepareTokenTransaction: ExternalPrepareTokenTransactionRequest;
+                tokenContext: ArrayBuffer;
+                totals: Array<BatchTotal>;
+                isSwap: boolean;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "UnsignedTransferPackage";
+        };
+        "new"(inner: {
+            prepareTokenTransaction: ExternalPrepareTokenTransactionRequest;
+            tokenContext: ArrayBuffer;
+            /**
+             * What the batch debits, per token. A batch spanning tokens has no
+             * single amount to report.
+             */ totals: Array<BatchTotal>;
+            /**
+             * When set, this package re-shapes the wallet's token outputs instead of
+             * sending a payment. Publishing it returns `SwapCompleted`: rebuild the
+             * original send from the same prepare response and submit again.
+             */ isSwap: boolean;
+        }): {
+            readonly tag: UnsignedTransferPackage_Tags.TokenBatch;
+            readonly inner: Readonly<{
+                prepareTokenTransaction: ExternalPrepareTokenTransactionRequest;
+                tokenContext: ArrayBuffer;
+                totals: Array<BatchTotal>;
+                isSwap: boolean;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "UnsignedTransferPackage";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: UnsignedTransferPackage_Tags.TokenBatch;
+            readonly inner: Readonly<{
+                prepareTokenTransaction: ExternalPrepareTokenTransactionRequest;
+                tokenContext: ArrayBuffer;
+                totals: Array<BatchTotal>;
+                isSwap: boolean;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "UnsignedTransferPackage";
+        };
+    };
 }>;
 export type UnsignedTransferPackage = InstanceType<(typeof UnsignedTransferPackage)[keyof Omit<typeof UnsignedTransferPackage, 'instanceOf'>]>;
 export declare enum UpdateDepositPayload_Tags {
@@ -18471,12 +20173,24 @@ export interface BitcoinChainService {
     getAddressUtxos(address: string, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<Array<Utxo>>;
+    /**
+     * Every output ever paid to `address`, spent or not, unlike
+     * [`get_address_utxos`](Self::get_address_utxos) which omits spent ones.
+     * Recovers an output's outpoint and value after it has been spent, so a
+     * swept refund can still be distinguished from one never broadcast.
+     */
+    getAddressTxos(address: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Array<Utxo>>;
     getTransactionStatus(txid: string, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<TxStatus>;
     getTransactionHex(txid: string, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<string>;
+    getOutspend(txid: string, vout: number, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Outspend>;
     broadcastTransaction(tx: string, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<void>;
@@ -18492,12 +20206,24 @@ export declare class BitcoinChainServiceImpl extends UniffiAbstractObject implem
     getAddressUtxos(address: string, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<Array<Utxo>>;
+    /**
+     * Every output ever paid to `address`, spent or not, unlike
+     * [`get_address_utxos`](Self::get_address_utxos) which omits spent ones.
+     * Recovers an output's outpoint and value after it has been spent, so a
+     * swept refund can still be distinguished from one never broadcast.
+     */
+    getAddressTxos(address: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Array<Utxo>>;
     getTransactionStatus(txid: string, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<TxStatus>;
     getTransactionHex(txid: string, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<string>;
+    getOutspend(txid: string, vout: number, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Outspend>;
     broadcastTransaction(tx: string, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<void>;
@@ -18558,6 +20284,16 @@ export interface BreezSdkInterface {
     authorizeLightningAddressTransfer(request: AuthorizeTransferRequest, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<TransferAuthorization>;
+    /**
+     * Builds the unsigned package for the batch prepared by
+     * [`BreezSdk::prepare_send_batch`], for signing outside the SDK.
+     *
+     * Publish the signed package with
+     * [`BreezSdk::publish_signed_transfer_package`], which returns every payment.
+     */
+    buildUnsignedBatchPackage(request: BuildUnsignedBatchPackageRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<UnsignedTransferPackage>;
     buildUnsignedLnurlPayPackage(request: BuildUnsignedLnurlPayPackageRequest, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<UnsignedTransferPackage>;
@@ -18813,9 +20549,34 @@ export interface BreezSdkInterface {
     prepareLnurlPay(request: PrepareLnurlPayRequest, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<PrepareLnurlPayResponse>;
+    /**
+     * Prepares a send to several payees, all paid by one transaction.
+     *
+     * Each recipient is a Spark address or a Spark invoice, and one batch may
+     * span several tokens. The response resolves every invoice into the asset
+     * and amount it requests, and reports what the batch debits per asset.
+     *
+     * A batch pays tokens: sending sats to several payees at once is not
+     * supported yet, so a recipient that resolves to sats is rejected.
+     *
+     * A batch that pays a Spark invoice is limited to a single token: the
+     * operators reject a transaction that carries an invoice and pays more
+     * than one. Send those as one batch per token.
+     */
+    prepareSendBatch(request: PrepareSendBatchRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<PrepareSendBatchResponse>;
     prepareSendPayment(request: PrepareSendPaymentRequest, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<PrepareSendPaymentResponse>;
+    /**
+     * Quotes a unilateral exit without any funding UTXOs: selects which leaves
+     * would exit, computes the exact fee for the given funding kind, and reports
+     * how much to fund.
+     */
+    prepareUnilateralExit(request: PrepareUnilateralExitRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<PrepareUnilateralExitResponse>;
     publishSignedLnurlPayPackage(request: PublishSignedLnurlPayPackageRequest, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<PublishSignedLnurlPayResponse>;
@@ -18835,19 +20596,20 @@ export interface BreezSdkInterface {
         signal: AbortSignal;
     }): Promise<RefundDepositResponse>;
     /**
-     * Runs one pass of the pending-conversion refunder.
+     * Runs one full pass of the pending-conversion refunder and returns how
+     * many conversions were refunded, skipped (held back by a safety window),
+     * or failed.
      *
-     * Iterates over payments whose conversions failed and have a refund
-     * pending, then attempts to refund each one. This is the same logic the
-     * SDK runs internally on a periodic schedule when
-     * `background_tasks_enabled` is `true`. When background tasks are
-     * disabled the periodic refunder does not run, and this method is the
-     * explicit entry point for driving the pass; when background tasks are
-     * enabled, it can be called to force an immediate refund pass.
+     * The pass has two parts: refunding locally-marked failed conversions, and
+     * reconciling against Flashnet's clawback-eligible listing to catch
+     * conversions with no local marker (e.g. a storage write that never
+     * landed). The SDK's periodic background schedule runs only the local
+     * part; the reconcile runs at SDK init and on each call to this method, so
+     * this is the explicit entry point for driving a full pass on demand.
      */
     refundPendingConversions(asyncOpts_?: {
         signal: AbortSignal;
-    }): Promise<void>;
+    }): Promise<RefundPendingConversionsResponse>;
     registerLightningAddress(request: RegisterLightningAddressRequest, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<LightningAddressInfo>;
@@ -18883,6 +20645,19 @@ export interface BreezSdkInterface {
     removeEventListener(id: string, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<boolean>;
+    /**
+     * Sends the batch prepared by [`BreezSdk::prepare_send_batch`], returning
+     * one payment per recipient in recipient order.
+     *
+     * Retrying after a failure that leaves the outcome unknown may pay twice:
+     * a token transfer has no idempotency key, since the operator can only be
+     * asked about a transaction by a hash that is computed while broadcasting.
+     * Look for the batch with a `Token` payment details filter on the
+     * transaction hash before sending it again.
+     */
+    sendBatch(request: SendBatchRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<SendBatchResponse>;
     sendPayment(request: SendPaymentRequest, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<SendPaymentResponse>;
@@ -18900,6 +20675,21 @@ export interface BreezSdkInterface {
     syncWallet(request: SyncWalletRequest, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<SyncWalletResponse>;
+    /**
+     * Builds and signs a complete unilateral exit from a `prepare_unilateral_exit`
+     * quote and the actual funding UTXOs, returning the full transaction set in
+     * topological broadcast order without broadcasting. Broadcast it over time,
+     * respecting each transaction's `depends_on` and `csv_timelock_blocks`.
+     *
+     * It resolves on-chain state first (see [`resolve_exit_observations`]): an
+     * already-confirmed fan-out or CPFP node is not rebuilt, and a leaf refund
+     * already on-chain (recognized by the leaf's refund address, so any refund
+     * variant counts) is swept directly. Re-running after partial progress
+     * therefore resumes rather than restarts.
+     */
+    unilateralExit(request: UnilateralExitRequest, signer: CpfpSigner, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<UnilateralExitResponse>;
     /**
      * Unregisters a previously registered webhook.
      *
@@ -18988,6 +20778,16 @@ export declare class BreezSdk extends UniffiAbstractObject implements BreezSdkIn
     authorizeLightningAddressTransfer(request: AuthorizeTransferRequest, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<TransferAuthorization>;
+    /**
+     * Builds the unsigned package for the batch prepared by
+     * [`BreezSdk::prepare_send_batch`], for signing outside the SDK.
+     *
+     * Publish the signed package with
+     * [`BreezSdk::publish_signed_transfer_package`], which returns every payment.
+     */
+    buildUnsignedBatchPackage(request: BuildUnsignedBatchPackageRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<UnsignedTransferPackage>;
     buildUnsignedLnurlPayPackage(request: BuildUnsignedLnurlPayPackageRequest, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<UnsignedTransferPackage>;
@@ -19243,9 +21043,34 @@ export declare class BreezSdk extends UniffiAbstractObject implements BreezSdkIn
     prepareLnurlPay(request: PrepareLnurlPayRequest, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<PrepareLnurlPayResponse>;
+    /**
+     * Prepares a send to several payees, all paid by one transaction.
+     *
+     * Each recipient is a Spark address or a Spark invoice, and one batch may
+     * span several tokens. The response resolves every invoice into the asset
+     * and amount it requests, and reports what the batch debits per asset.
+     *
+     * A batch pays tokens: sending sats to several payees at once is not
+     * supported yet, so a recipient that resolves to sats is rejected.
+     *
+     * A batch that pays a Spark invoice is limited to a single token: the
+     * operators reject a transaction that carries an invoice and pays more
+     * than one. Send those as one batch per token.
+     */
+    prepareSendBatch(request: PrepareSendBatchRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<PrepareSendBatchResponse>;
     prepareSendPayment(request: PrepareSendPaymentRequest, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<PrepareSendPaymentResponse>;
+    /**
+     * Quotes a unilateral exit without any funding UTXOs: selects which leaves
+     * would exit, computes the exact fee for the given funding kind, and reports
+     * how much to fund.
+     */
+    prepareUnilateralExit(request: PrepareUnilateralExitRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<PrepareUnilateralExitResponse>;
     publishSignedLnurlPayPackage(request: PublishSignedLnurlPayPackageRequest, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<PublishSignedLnurlPayResponse>;
@@ -19265,19 +21090,20 @@ export declare class BreezSdk extends UniffiAbstractObject implements BreezSdkIn
         signal: AbortSignal;
     }): Promise<RefundDepositResponse>;
     /**
-     * Runs one pass of the pending-conversion refunder.
+     * Runs one full pass of the pending-conversion refunder and returns how
+     * many conversions were refunded, skipped (held back by a safety window),
+     * or failed.
      *
-     * Iterates over payments whose conversions failed and have a refund
-     * pending, then attempts to refund each one. This is the same logic the
-     * SDK runs internally on a periodic schedule when
-     * `background_tasks_enabled` is `true`. When background tasks are
-     * disabled the periodic refunder does not run, and this method is the
-     * explicit entry point for driving the pass; when background tasks are
-     * enabled, it can be called to force an immediate refund pass.
+     * The pass has two parts: refunding locally-marked failed conversions, and
+     * reconciling against Flashnet's clawback-eligible listing to catch
+     * conversions with no local marker (e.g. a storage write that never
+     * landed). The SDK's periodic background schedule runs only the local
+     * part; the reconcile runs at SDK init and on each call to this method, so
+     * this is the explicit entry point for driving a full pass on demand.
      */
     refundPendingConversions(asyncOpts_?: {
         signal: AbortSignal;
-    }): Promise<void>;
+    }): Promise<RefundPendingConversionsResponse>;
     registerLightningAddress(request: RegisterLightningAddressRequest, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<LightningAddressInfo>;
@@ -19313,6 +21139,19 @@ export declare class BreezSdk extends UniffiAbstractObject implements BreezSdkIn
     removeEventListener(id: string, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<boolean>;
+    /**
+     * Sends the batch prepared by [`BreezSdk::prepare_send_batch`], returning
+     * one payment per recipient in recipient order.
+     *
+     * Retrying after a failure that leaves the outcome unknown may pay twice:
+     * a token transfer has no idempotency key, since the operator can only be
+     * asked about a transaction by a hash that is computed while broadcasting.
+     * Look for the batch with a `Token` payment details filter on the
+     * transaction hash before sending it again.
+     */
+    sendBatch(request: SendBatchRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<SendBatchResponse>;
     sendPayment(request: SendPaymentRequest, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<SendPaymentResponse>;
@@ -19330,6 +21169,21 @@ export declare class BreezSdk extends UniffiAbstractObject implements BreezSdkIn
     syncWallet(request: SyncWalletRequest, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<SyncWalletResponse>;
+    /**
+     * Builds and signs a complete unilateral exit from a `prepare_unilateral_exit`
+     * quote and the actual funding UTXOs, returning the full transaction set in
+     * topological broadcast order without broadcasting. Broadcast it over time,
+     * respecting each transaction's `depends_on` and `csv_timelock_blocks`.
+     *
+     * It resolves on-chain state first (see [`resolve_exit_observations`]): an
+     * already-confirmed fan-out or CPFP node is not rebuilt, and a leaf refund
+     * already on-chain (recognized by the leaf's refund address, so any refund
+     * variant counts) is swept directly. Re-running after partial progress
+     * therefore resumes rather than restarts.
+     */
+    unilateralExit(request: UnilateralExitRequest, signer: CpfpSigner, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<UnilateralExitResponse>;
     /**
      * Unregisters a previously registered webhook.
      *
@@ -19371,6 +21225,37 @@ export declare class BreezSdk extends UniffiAbstractObject implements BreezSdkIn
     uniffiDestroy(): void;
     static instanceOf(obj: any): obj is BreezSdk;
 }
+/**
+ * Signer for external UTXO inputs in CPFP fee-bumping transactions.
+ *
+ * Signs the non-finalized inputs of a PSBT (serialized as bytes) and returns the
+ * signed PSBT (also serialized as bytes).
+ */
+export interface CpfpSigner {
+    signPsbt(psbtBytes: ArrayBuffer, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ArrayBuffer>;
+}
+/**
+ * Signer for external UTXO inputs in CPFP fee-bumping transactions.
+ *
+ * Signs the non-finalized inputs of a PSBT (serialized as bytes) and returns the
+ * signed PSBT (also serialized as bytes).
+ */
+export declare class CpfpSignerImpl extends UniffiAbstractObject implements CpfpSigner {
+    readonly [uniffiTypeNameSymbol] = "CpfpSignerImpl";
+    readonly [destructorGuardSymbol]: UniffiRustArcPtr;
+    readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
+    private constructor();
+    signPsbt(psbtBytes: ArrayBuffer, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ArrayBuffer>;
+    /**
+     * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+     */
+    uniffiDestroy(): void;
+    static instanceOf(obj: any): obj is CpfpSignerImpl;
+}
 /**
  * External signer trait that can be implemented by users and passed to the SDK.
  *
@@ -19796,6 +21681,13 @@ export interface ExternalSparkSigner {
     signMessage(message: ArrayBuffer, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<EcdsaSignatureBytes>;
+    /**
+     * Schnorr-sign `sighash` to spend a tree leaf's P2TR refund output as a
+     * BIP341 key-path spend (empty script tree).
+     */
+    signLeafRefundSpend(leafId: ExternalTreeNodeId, sighash: ArrayBuffer, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<SchnorrSignatureBytes>;
     /**
      * Produce FROST shares for a batch of jobs.
      */
@@ -19902,6 +21794,13 @@ export declare class ExternalSparkSignerImpl extends UniffiAbstractObject implem
     signMessage(message: ArrayBuffer, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<EcdsaSignatureBytes>;
+    /**
+     * Schnorr-sign `sighash` to spend a tree leaf's P2TR refund output as a
+     * BIP341 key-path spend (empty script tree).
+     */
+    signLeafRefundSpend(leafId: ExternalTreeNodeId, sighash: ArrayBuffer, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<SchnorrSignatureBytes>;
     /**
      * Produce FROST shares for a batch of jobs.
      */
@@ -20065,10 +21964,12 @@ export interface PasskeyClientInterface {
      */
     labels(): PasskeyLabelsInterface;
     /**
-     * First-time setup. Drives [`PrfProvider::create_passkey`] (one
-     * ceremony) followed by the wallet-derivation flow that backs
-     * [`Passkey::setup_wallet`] (one ceremony, dual-salt where
-     * supported). The label is always published on success.
+     * First-time setup. Drives [`PrfProvider::create_passkey`], which
+     * returns the seeds inline where the platform evaluates PRF during
+     * the create ceremony; otherwise the wallet-derivation flow behind
+     * [`Passkey::setup_wallet`] runs as a second ceremony. The label is
+     * validated before anything is created, and published in the
+     * background: it may still be in flight when this returns `Ok`.
      */
     register(request: RegisterRequest, asyncOpts_?: {
         signal: AbortSignal;
@@ -20144,10 +22045,12 @@ export declare class PasskeyClient extends UniffiAbstractObject implements Passk
      */
     labels(): PasskeyLabelsInterface;
     /**
-     * First-time setup. Drives [`PrfProvider::create_passkey`] (one
-     * ceremony) followed by the wallet-derivation flow that backs
-     * [`Passkey::setup_wallet`] (one ceremony, dual-salt where
-     * supported). The label is always published on success.
+     * First-time setup. Drives [`PrfProvider::create_passkey`], which
+     * returns the seeds inline where the platform evaluates PRF during
+     * the create ceremony; otherwise the wallet-derivation flow behind
+     * [`Passkey::setup_wallet`] runs as a second ceremony. The label is
+     * validated before anything is created, and published in the
+     * background: it may still be in flight when this returns `Ok`.
      */
     register(request: RegisterRequest, asyncOpts_?: {
         signal: AbortSignal;
@@ -20300,19 +22203,33 @@ export interface PrfProvider {
         signal: AbortSignal;
     }): Promise<boolean>;
     /**
-     * Explicit registration. Platform passkey providers override this to
-     * drive the OS create ceremony and surface the credential metadata
-     * hosts need for `exclude_credentials` bookkeeping. CLI / hardware
-     * providers register lazily in [`Self::derive_seeds`] and inherit the
-     * default `PrfNotSupported`.
+     * Explicit registration: drive the OS create ceremony, and where the
+     * platform supports it, evaluate PRF for `salts` in the same
+     * ceremony. Platform passkey providers override this to surface the
+     * credential metadata hosts need for `exclude_credentials`
+     * bookkeeping. CLI / hardware providers register lazily in
+     * [`Self::derive_seeds`] and inherit the default `PrfNotSupported`.
      *
      * `exclude_credentials` lists already-registered IDs and surfaces
      * duplicates as `CredentialAlreadyExists`. The `user.id` is always
      * provider-minted and returned on `PasskeyCredential.user_id`.
+     *
+     * Returning seeds removes the assertion that would otherwise follow
+     * a create, and with it the window where the new credential exists
+     * but the platform cannot yet resolve it. Return `seeds: None` for
+     * anything short of one output per salt (some authenticators drop
+     * `prf.eval.second`): a partial result is not usable, and the caller
+     * falls back to [`Self::derive_seeds`]. Empty `salts` means the
+     * caller wants the credential only.
+     *
+     * Seeds returned here must equal what [`Self::derive_seeds`] would
+     * return for the same salts. The wallet is derived from them either
+     * way, so a mismatch means register and sign-in land on different
+     * wallets, and the one register created is unreachable.
      */
-    createPasskey(excludeCredentials: Array<ArrayBuffer>, asyncOpts_?: {
+    createPasskey(excludeCredentials: Array<ArrayBuffer>, salts: Array<string>, asyncOpts_?: {
         signal: AbortSignal;
-    }): Promise<PasskeyCredential>;
+    }): Promise<CreatePasskeyOutput>;
     /**
      * Advisory check against the platform's out-of-band verification
      * source (iOS AASA / Android assetlinks / browser rpId scope).
@@ -20370,19 +22287,33 @@ export declare class PrfProviderImpl extends UniffiAbstractObject implements Prf
         signal: AbortSignal;
     }): Promise<boolean>;
     /**
-     * Explicit registration. Platform passkey providers override this to
-     * drive the OS create ceremony and surface the credential metadata
-     * hosts need for `exclude_credentials` bookkeeping. CLI / hardware
-     * providers register lazily in [`Self::derive_seeds`] and inherit the
-     * default `PrfNotSupported`.
+     * Explicit registration: drive the OS create ceremony, and where the
+     * platform supports it, evaluate PRF for `salts` in the same
+     * ceremony. Platform passkey providers override this to surface the
+     * credential metadata hosts need for `exclude_credentials`
+     * bookkeeping. CLI / hardware providers register lazily in
+     * [`Self::derive_seeds`] and inherit the default `PrfNotSupported`.
      *
      * `exclude_credentials` lists already-registered IDs and surfaces
      * duplicates as `CredentialAlreadyExists`. The `user.id` is always
      * provider-minted and returned on `PasskeyCredential.user_id`.
+     *
+     * Returning seeds removes the assertion that would otherwise follow
+     * a create, and with it the window where the new credential exists
+     * but the platform cannot yet resolve it. Return `seeds: None` for
+     * anything short of one output per salt (some authenticators drop
+     * `prf.eval.second`): a partial result is not usable, and the caller
+     * falls back to [`Self::derive_seeds`]. Empty `salts` means the
+     * caller wants the credential only.
+     *
+     * Seeds returned here must equal what [`Self::derive_seeds`] would
+     * return for the same salts. The wallet is derived from them either
+     * way, so a mismatch means register and sign-in land on different
+     * wallets, and the one register created is unreachable.
      */
-    createPasskey(excludeCredentials: Array<ArrayBuffer>, asyncOpts_?: {
+    createPasskey(excludeCredentials: Array<ArrayBuffer>, salts: Array<string>, asyncOpts_?: {
         signal: AbortSignal;
-    }): Promise<PasskeyCredential>;
+    }): Promise<CreatePasskeyOutput>;
     /**
      * Advisory check against the platform's out-of-band verification
      * source (iOS AASA / Android assetlinks / browser rpId scope).
@@ -21710,6 +23641,27 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): AutoOptimizationEvent;
             lower(value: AutoOptimizationEvent): UniffiByteArray;
         };
+        FfiConverterTypeBatchDestination: {
+            read(from: RustBuffer): BatchDestination;
+            write(value: BatchDestination, into: RustBuffer): void;
+            allocationSize(value: BatchDestination): number;
+            lift(value: UniffiByteArray): BatchDestination;
+            lower(value: BatchDestination): UniffiByteArray;
+        };
+        FfiConverterTypeBatchRecipient: {
+            read(from: RustBuffer): BatchRecipient;
+            write(value: BatchRecipient, into: RustBuffer): void;
+            allocationSize(value: BatchRecipient): number;
+            lift(value: UniffiByteArray): BatchRecipient;
+            lower(value: BatchRecipient): UniffiByteArray;
+        };
+        FfiConverterTypeBatchTotal: {
+            read(from: RustBuffer): BatchTotal;
+            write(value: BatchTotal, into: RustBuffer): void;
+            allocationSize(value: BatchTotal): number;
+            lift(value: UniffiByteArray): BatchTotal;
+            lower(value: BatchTotal): UniffiByteArray;
+        };
         FfiConverterTypeBip21Details: {
             read(from: RustBuffer): Bip21Details;
             write(value: Bip21Details, into: RustBuffer): void;
@@ -21817,6 +23769,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): BuildTransferPackageOptions;
             lower(value: BuildTransferPackageOptions): UniffiByteArray;
         };
+        FfiConverterTypeBuildUnsignedBatchPackageRequest: {
+            read(from: RustBuffer): BuildUnsignedBatchPackageRequest;
+            write(value: BuildUnsignedBatchPackageRequest, into: RustBuffer): void;
+            allocationSize(value: BuildUnsignedBatchPackageRequest): number;
+            lift(value: UniffiByteArray): BuildUnsignedBatchPackageRequest;
+            lower(value: BuildUnsignedBatchPackageRequest): UniffiByteArray;
+        };
         FfiConverterTypeBuildUnsignedLnurlPayPackageRequest: {
             read(from: RustBuffer): BuildUnsignedLnurlPayPackageRequest;
             write(value: BuildUnsignedLnurlPayPackageRequest, into: RustBuffer): void;
@@ -21929,6 +23888,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): Config;
             lower(value: Config): UniffiByteArray;
         };
+        FfiConverterTypeConfirmationStatus: {
+            read(from: RustBuffer): ConfirmationStatus;
+            write(value: ConfirmationStatus, into: RustBuffer): void;
+            allocationSize(value: ConfirmationStatus): number;
+            lift(value: UniffiByteArray): ConfirmationStatus;
+            lower(value: ConfirmationStatus): UniffiByteArray;
+        };
         FfiConverterTypeConnectRequest: {
             read(from: RustBuffer): ConnectRequest;
             write(value: ConnectRequest, into: RustBuffer): void;
@@ -22062,6 +24028,21 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): ConversionType;
             lower(value: ConversionType): UniffiByteArray;
         };
+        FfiConverterTypeCpfpFundingKind: {
+            read(from: RustBuffer): CpfpFundingKind;
+            write(value: CpfpFundingKind, into: RustBuffer): void;
+            allocationSize(value: CpfpFundingKind): number;
+            lift(value: UniffiByteArray): CpfpFundingKind;
+            lower(value: CpfpFundingKind): UniffiByteArray;
+        };
+        FfiConverterTypeCpfpInput: {
+            read(from: RustBuffer): CpfpInput;
+            write(value: CpfpInput, into: RustBuffer): void;
+            allocationSize(value: CpfpInput): number;
+            lift(value: UniffiByteArray): CpfpInput;
+            lower(value: CpfpInput): UniffiByteArray;
+        };
+        FfiConverterTypeCpfpSigner: FfiConverterObjectWithCallbacks<CpfpSigner>;
         FfiConverterTypeCreateIssuerTokenRequest: {
             read(from: RustBuffer): CreateIssuerTokenRequest;
             write(value: CreateIssuerTokenRequest, into: RustBuffer): void;
@@ -22069,6 +24050,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): CreateIssuerTokenRequest;
             lower(value: CreateIssuerTokenRequest): UniffiByteArray;
         };
+        FfiConverterTypeCreatePasskeyOutput: {
+            read(from: RustBuffer): CreatePasskeyOutput;
+            write(value: CreatePasskeyOutput, into: RustBuffer): void;
+            allocationSize(value: CreatePasskeyOutput): number;
+            lift(value: UniffiByteArray): CreatePasskeyOutput;
+            lower(value: CreatePasskeyOutput): UniffiByteArray;
+        };
         FfiConverterTypeCredentials: {
             read(from: RustBuffer): Credentials;
             write(value: Credentials, into: RustBuffer): void;
@@ -22188,6 +24176,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): ErrorKind;
             lower(value: ErrorKind): UniffiByteArray;
         };
+        FfiConverterTypeExitLeafSelection: {
+            read(from: RustBuffer): ExitLeafSelection;
+            write(value: ExitLeafSelection, into: RustBuffer): void;
+            allocationSize(value: ExitLeafSelection): number;
+            lift(value: UniffiByteArray): ExitLeafSelection;
+            lower(value: ExitLeafSelection): UniffiByteArray;
+        };
         FfiConverterTypeExternalBreezSigner: FfiConverterObjectWithCallbacks<ExternalBreezSigner>;
         FfiConverterTypeExternalClaimLeafInput: {
             read(from: RustBuffer): ExternalClaimLeafInput;
@@ -22836,6 +24831,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): OutgoingChange;
             lower(value: OutgoingChange): UniffiByteArray;
         };
+        FfiConverterTypeOutspend: {
+            read(from: RustBuffer): Outspend;
+            write(value: Outspend, into: RustBuffer): void;
+            allocationSize(value: Outspend): number;
+            lift(value: UniffiByteArray): Outspend;
+            lower(value: Outspend): UniffiByteArray;
+        };
         FfiConverterTypePasskeyAvailability: {
             read(from: RustBuffer): PasskeyAvailability;
             write(value: PasskeyAvailability, into: RustBuffer): void;
@@ -22951,6 +24953,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): PaymentType;
             lower(value: PaymentType): UniffiByteArray;
         };
+        FfiConverterTypePerBranchFunding: {
+            read(from: RustBuffer): PerBranchFunding;
+            write(value: PerBranchFunding, into: RustBuffer): void;
+            allocationSize(value: PerBranchFunding): number;
+            lift(value: UniffiByteArray): PerBranchFunding;
+            lower(value: PerBranchFunding): UniffiByteArray;
+        };
         FfiConverterTypePrepareLnurlPayRequest: {
             read(from: RustBuffer): PrepareLnurlPayRequest;
             write(value: PrepareLnurlPayRequest, into: RustBuffer): void;
@@ -22965,6 +24974,20 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): PrepareLnurlPayResponse;
             lower(value: PrepareLnurlPayResponse): UniffiByteArray;
         };
+        FfiConverterTypePrepareSendBatchRequest: {
+            read(from: RustBuffer): PrepareSendBatchRequest;
+            write(value: PrepareSendBatchRequest, into: RustBuffer): void;
+            allocationSize(value: PrepareSendBatchRequest): number;
+            lift(value: UniffiByteArray): PrepareSendBatchRequest;
+            lower(value: PrepareSendBatchRequest): UniffiByteArray;
+        };
+        FfiConverterTypePrepareSendBatchResponse: {
+            read(from: RustBuffer): PrepareSendBatchResponse;
+            write(value: PrepareSendBatchResponse, into: RustBuffer): void;
+            allocationSize(value: PrepareSendBatchResponse): number;
+            lift(value: UniffiByteArray): PrepareSendBatchResponse;
+            lower(value: PrepareSendBatchResponse): UniffiByteArray;
+        };
         FfiConverterTypePrepareSendPaymentRequest: {
             read(from: RustBuffer): PrepareSendPaymentRequest;
             write(value: PrepareSendPaymentRequest, into: RustBuffer): void;
@@ -22979,6 +25002,20 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): PrepareSendPaymentResponse;
             lower(value: PrepareSendPaymentResponse): UniffiByteArray;
         };
+        FfiConverterTypePrepareUnilateralExitRequest: {
+            read(from: RustBuffer): PrepareUnilateralExitRequest;
+            write(value: PrepareUnilateralExitRequest, into: RustBuffer): void;
+            allocationSize(value: PrepareUnilateralExitRequest): number;
+            lift(value: UniffiByteArray): PrepareUnilateralExitRequest;
+            lower(value: PrepareUnilateralExitRequest): UniffiByteArray;
+        };
+        FfiConverterTypePrepareUnilateralExitResponse: {
+            read(from: RustBuffer): PrepareUnilateralExitResponse;
+            write(value: PrepareUnilateralExitResponse, into: RustBuffer): void;
+            allocationSize(value: PrepareUnilateralExitResponse): number;
+            lift(value: UniffiByteArray): PrepareUnilateralExitResponse;
+            lower(value: PrepareUnilateralExitResponse): UniffiByteArray;
+        };
         FfiConverterTypePrfProvider: FfiConverterObjectWithCallbacks<PrfProvider>;
         FfiConverterTypePrfProviderError: {
             read(from: RustBuffer): PrfProviderError;
@@ -23114,6 +25151,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): RefundDepositResponse;
             lower(value: RefundDepositResponse): UniffiByteArray;
         };
+        FfiConverterTypeRefundPendingConversionsResponse: {
+            read(from: RustBuffer): RefundPendingConversionsResponse;
+            write(value: RefundPendingConversionsResponse, into: RustBuffer): void;
+            allocationSize(value: RefundPendingConversionsResponse): number;
+            lift(value: UniffiByteArray): RefundPendingConversionsResponse;
+            lower(value: RefundPendingConversionsResponse): UniffiByteArray;
+        };
         FfiConverterTypeRegisterLightningAddressRequest: {
             read(from: RustBuffer): RegisterLightningAddressRequest;
             write(value: RegisterLightningAddressRequest, into: RustBuffer): void;
@@ -23149,6 +25193,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): RegisterWebhookResponse;
             lower(value: RegisterWebhookResponse): UniffiByteArray;
         };
+        FfiConverterTypeResolvedBatchRecipient: {
+            read(from: RustBuffer): ResolvedBatchRecipient;
+            write(value: ResolvedBatchRecipient, into: RustBuffer): void;
+            allocationSize(value: ResolvedBatchRecipient): number;
+            lift(value: UniffiByteArray): ResolvedBatchRecipient;
+            lower(value: ResolvedBatchRecipient): UniffiByteArray;
+        };
         FfiConverterTypeResolvedStores: FfiConverterObject<ResolvedStoresInterface>;
         FfiConverterTypeRestClient: FfiConverterObjectWithCallbacks<RestClient>;
         FfiConverterTypeRestResponse: {
@@ -23202,6 +25253,20 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): Seed;
             lower(value: Seed): UniffiByteArray;
         };
+        FfiConverterTypeSendBatchRequest: {
+            read(from: RustBuffer): SendBatchRequest;
+            write(value: SendBatchRequest, into: RustBuffer): void;
+            allocationSize(value: SendBatchRequest): number;
+            lift(value: UniffiByteArray): SendBatchRequest;
+            lower(value: SendBatchRequest): UniffiByteArray;
+        };
+        FfiConverterTypeSendBatchResponse: {
+            read(from: RustBuffer): SendBatchResponse;
+            write(value: SendBatchResponse, into: RustBuffer): void;
+            allocationSize(value: SendBatchResponse): number;
+            lift(value: UniffiByteArray): SendBatchResponse;
+            lower(value: SendBatchResponse): UniffiByteArray;
+        };
         FfiConverterTypeSendOnchainFeeQuote: {
             read(from: RustBuffer): SendOnchainFeeQuote;
             write(value: SendOnchainFeeQuote, into: RustBuffer): void;
@@ -23399,6 +25464,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): SparkInvoicePaymentDetails;
             lower(value: SparkInvoicePaymentDetails): UniffiByteArray;
         };
+        FfiConverterTypeSparkMasterIdentityPublicKey: {
+            read(from: RustBuffer): SparkMasterIdentityPublicKey;
+            write(value: SparkMasterIdentityPublicKey, into: RustBuffer): void;
+            allocationSize(value: SparkMasterIdentityPublicKey): number;
+            lift(value: UniffiByteArray): SparkMasterIdentityPublicKey;
+            lower(value: SparkMasterIdentityPublicKey): UniffiByteArray;
+        };
         FfiConverterTypeSparkSigningOperator: {
             read(from: RustBuffer): SparkSigningOperator;
             write(value: SparkSigningOperator, into: RustBuffer): void;
@@ -23591,6 +25663,41 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): UnfreezeIssuerTokenResponse;
             lower(value: UnfreezeIssuerTokenResponse): UniffiByteArray;
         };
+        FfiConverterTypeUnilateralExitLeaf: {
+            read(from: RustBuffer): UnilateralExitLeaf;
+            write(value: UnilateralExitLeaf, into: RustBuffer): void;
+            allocationSize(value: UnilateralExitLeaf): number;
+            lift(value: UniffiByteArray): UnilateralExitLeaf;
+            lower(value: UnilateralExitLeaf): UniffiByteArray;
+        };
+        FfiConverterTypeUnilateralExitRequest: {
+            read(from: RustBuffer): UnilateralExitRequest;
+            write(value: UnilateralExitRequest, into: RustBuffer): void;
+            allocationSize(value: UnilateralExitRequest): number;
+            lift(value: UniffiByteArray): UnilateralExitRequest;
+            lower(value: UnilateralExitRequest): UniffiByteArray;
+        };
+        FfiConverterTypeUnilateralExitResponse: {
+            read(from: RustBuffer): UnilateralExitResponse;
+            write(value: UnilateralExitResponse, into: RustBuffer): void;
+            allocationSize(value: UnilateralExitResponse): number;
+            lift(value: UniffiByteArray): UnilateralExitResponse;
+            lower(value: UnilateralExitResponse): UniffiByteArray;
+        };
+        FfiConverterTypeUnilateralExitTransaction: {
+            read(from: RustBuffer): UnilateralExitTransaction;
+            write(value: UnilateralExitTransaction, into: RustBuffer): void;
+            allocationSize(value: UnilateralExitTransaction): number;
+            lift(value: UniffiByteArray): UnilateralExitTransaction;
+            lower(value: UnilateralExitTransaction): UniffiByteArray;
+        };
+        FfiConverterTypeUnilateralExitTxKind: {
+            read(from: RustBuffer): UnilateralExitTxKind;
+            write(value: UnilateralExitTxKind, into: RustBuffer): void;
+            allocationSize(value: UnilateralExitTxKind): number;
+            lift(value: UniffiByteArray): UnilateralExitTxKind;
+            lower(value: UnilateralExitTxKind): UniffiByteArray;
+        };
         FfiConverterTypeUnregisterWebhookRequest: {
             read(from: RustBuffer): UnregisterWebhookRequest;
             write(value: UnregisterWebhookRequest, into: RustBuffer): void;