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

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

@@ -133,6 +133,21 @@ export declare function defaultExternalSigners(mnemonic: string, passphrase: str
  * an invalid-input error
  */
 export declare function defaultServerConfig(network: Network): Config;
+/**
+ * The session store `backend` provides for `identity` on `network` (its own
+ * persistence: `PostgreSQL`/`MySQL` when the backend is DB-backed, else an
+ * in-memory store).
+ *
+ * Returned so it can be wrapped in a decorating [`SessionStore`] and passed to
+ * [`SdkBuilder::with_session_store`](crate::SdkBuilder::with_session_store),
+ * keeping the backend's persistence. A typical use is at-rest encryption (the
+ * SDK does not encrypt tokens itself): wrap it in a store that encrypts on
+ * write and decrypts on read. `identity` is the wallet identity public key
+ * bytes (the same value the SDK derives from the signer).
+ */
+export declare function defaultSessionStore(backend: StorageBackend, network: Network, identity: ArrayBuffer, asyncOpts_?: {
+    signal: AbortSignal;
+}): Promise<SessionStore>;
 /**
  * File-based `SQLite` storage rooted at `storage_dir` — the default for
  * mobile and desktop apps. Each tenant gets its own database file under the
@@ -654,6 +669,51 @@ export declare const Bolt12OfferDetails: Readonly<{
      */
     defaults: () => Partial<Bolt12OfferDetails>;
 }>;
+export type BuildUnsignedLnurlPayPackageRequest = {
+    prepareResponse: PrepareLnurlPayResponse;
+};
+/**
+ * Generated factory for {@link BuildUnsignedLnurlPayPackageRequest} record objects.
+ */
+export declare const BuildUnsignedLnurlPayPackageRequest: Readonly<{
+    /**
+     * Create a frozen instance of {@link BuildUnsignedLnurlPayPackageRequest}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create: (partial: Partial<BuildUnsignedLnurlPayPackageRequest> & Required<Omit<BuildUnsignedLnurlPayPackageRequest, never>>) => BuildUnsignedLnurlPayPackageRequest;
+    /**
+     * Create a frozen instance of {@link BuildUnsignedLnurlPayPackageRequest}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: (partial: Partial<BuildUnsignedLnurlPayPackageRequest> & Required<Omit<BuildUnsignedLnurlPayPackageRequest, never>>) => BuildUnsignedLnurlPayPackageRequest;
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Partial<BuildUnsignedLnurlPayPackageRequest>;
+}>;
+export type BuildUnsignedTransferPackageRequest = {
+    prepareResponse: PrepareSendPaymentResponse;
+    options: BuildTransferPackageOptions | undefined;
+};
+/**
+ * Generated factory for {@link BuildUnsignedTransferPackageRequest} record objects.
+ */
+export declare const BuildUnsignedTransferPackageRequest: Readonly<{
+    /**
+     * Create a frozen instance of {@link BuildUnsignedTransferPackageRequest}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create: (partial: Partial<BuildUnsignedTransferPackageRequest> & Required<Omit<BuildUnsignedTransferPackageRequest, "options">>) => BuildUnsignedTransferPackageRequest;
+    /**
+     * Create a frozen instance of {@link BuildUnsignedTransferPackageRequest}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: (partial: Partial<BuildUnsignedTransferPackageRequest> & Required<Omit<BuildUnsignedTransferPackageRequest, "options">>) => BuildUnsignedTransferPackageRequest;
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Partial<BuildUnsignedTransferPackageRequest>;
+}>;
 export type BurnIssuerTokenRequest = {
     amount: U128;
 };
@@ -1081,10 +1141,11 @@ export type ConnectWithPasskeyRequest = {
      */
     label: string | undefined;
     /**
-     * Optional credential IDs to restrict the silent sign-in
-     * attempt to (reauthentication path). See
-     * [`SignInRequest::allow_credentials`]. Ignored on the fallback
-     * registration path.
+     * Optional credential IDs to restrict the sign-in attempt to
+     * (reauthentication path). A non-empty list runs the modal sign-in
+     * rather than the immediate probe (a pin means a credential is already
+     * known). See [`SignInRequest::allow_credentials`]. Ignored on the
+     * fallback registration path.
      */
     allowCredentials: Array<ArrayBuffer> | undefined;
     /**
@@ -1121,10 +1182,17 @@ export declare const ConnectWithPasskeyRequest: Readonly<{
  * registered, when the provider surfaces it. The register path also
  * populates the attestation fields (`aaguid`, `backup_eligible`); the
  * sign-in path sets only `credential_id`.
+ *
+ * `labels` is the user's discovered label set when `request.label` was
+ * `None` (the returning-user multi-wallet case): `wallet` is the default
+ * label, and a host showing more than one entry lets the user pick
+ * another via [`PasskeyClient::sign_in`]. Empty on the register path (a
+ * new user has no other labels) and when a specific label was requested.
  */
 export type ConnectWithPasskeyResponse = {
     wallet: Wallet;
     credential: PasskeyCredential | undefined;
+    labels: Array<string>;
 };
 /**
  * Generated factory for {@link ConnectWithPasskeyResponse} record objects.
@@ -3603,6 +3671,30 @@ export declare const LnurlInfo: Readonly<{
      */
     defaults: () => Partial<LnurlInfo>;
 }>;
+export type LnurlPayContext = {
+    payRequest: LnurlPayRequestDetails;
+    comment: string | undefined;
+    successAction: SuccessAction | undefined;
+};
+/**
+ * Generated factory for {@link LnurlPayContext} record objects.
+ */
+export declare const LnurlPayContext: Readonly<{
+    /**
+     * Create a frozen instance of {@link LnurlPayContext}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create: (partial: Partial<LnurlPayContext> & Required<Omit<LnurlPayContext, never>>) => LnurlPayContext;
+    /**
+     * Create a frozen instance of {@link LnurlPayContext}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: (partial: Partial<LnurlPayContext> & Required<Omit<LnurlPayContext, never>>) => LnurlPayContext;
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Partial<LnurlPayContext>;
+}>;
 /**
  * Represents the payment LNURL info
  */
@@ -4632,6 +4724,50 @@ export declare const PublicKeyBytes: Readonly<{
      */
     defaults: () => Partial<PublicKeyBytes>;
 }>;
+export type PublishSignedLnurlPayPackageRequest = {
+    signedPackage: SignedTransferPackage;
+};
+/**
+ * Generated factory for {@link PublishSignedLnurlPayPackageRequest} record objects.
+ */
+export declare const PublishSignedLnurlPayPackageRequest: Readonly<{
+    /**
+     * Create a frozen instance of {@link PublishSignedLnurlPayPackageRequest}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create: (partial: Partial<PublishSignedLnurlPayPackageRequest> & Required<Omit<PublishSignedLnurlPayPackageRequest, never>>) => PublishSignedLnurlPayPackageRequest;
+    /**
+     * Create a frozen instance of {@link PublishSignedLnurlPayPackageRequest}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: (partial: Partial<PublishSignedLnurlPayPackageRequest> & Required<Omit<PublishSignedLnurlPayPackageRequest, never>>) => PublishSignedLnurlPayPackageRequest;
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Partial<PublishSignedLnurlPayPackageRequest>;
+}>;
+export type PublishSignedTransferPackageRequest = {
+    signedPackage: SignedTransferPackage;
+};
+/**
+ * Generated factory for {@link PublishSignedTransferPackageRequest} record objects.
+ */
+export declare const PublishSignedTransferPackageRequest: Readonly<{
+    /**
+     * Create a frozen instance of {@link PublishSignedTransferPackageRequest}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create: (partial: Partial<PublishSignedTransferPackageRequest> & Required<Omit<PublishSignedTransferPackageRequest, never>>) => PublishSignedTransferPackageRequest;
+    /**
+     * Create a frozen instance of {@link PublishSignedTransferPackageRequest}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: (partial: Partial<PublishSignedTransferPackageRequest> & Required<Omit<PublishSignedTransferPackageRequest, never>>) => PublishSignedTransferPackageRequest;
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Partial<PublishSignedTransferPackageRequest>;
+}>;
 /**
  * Denominator in an exchange rate
  */
@@ -5496,6 +5632,29 @@ export declare const SignMessageResponse: Readonly<{
      */
     defaults: () => Partial<SignMessageResponse>;
 }>;
+export type SignedTransferPackage = {
+    unsigned: UnsignedTransferPackage;
+    signature: TransferSignature;
+};
+/**
+ * Generated factory for {@link SignedTransferPackage} record objects.
+ */
+export declare const SignedTransferPackage: Readonly<{
+    /**
+     * Create a frozen instance of {@link SignedTransferPackage}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    create: (partial: Partial<SignedTransferPackage> & Required<Omit<SignedTransferPackage, never>>) => SignedTransferPackage;
+    /**
+     * Create a frozen instance of {@link SignedTransferPackage}, with defaults specified
+     * in Rust, in the {@link breez_sdk_spark} crate.
+     */
+    new: (partial: Partial<SignedTransferPackage> & Required<Omit<SignedTransferPackage, never>>) => SignedTransferPackage;
+    /**
+     * Defaults specified in the {@link breez_sdk_spark} crate.
+     */
+    defaults: () => Partial<SignedTransferPackage>;
+}>;
 /**
  * A signing-only external signer paired with the Spark signer, for wallets that
  * connect via [`connect_with_signing_only_signer`]. The Breez half performs
@@ -5617,6 +5776,12 @@ export type SparkConfig = {
      * Expected relative block locktime for token withdrawals.
      */
     expectedWithdrawRelativeBlockLocktime: bigint;
+    /**
+     * Cap on the inputs a single token transaction may spend. A send needing
+     * more first consolidates the wallet's token outputs. Unset uses the SDK
+     * default (500).
+     */
+    maxTokenTransactionInputs: /*u32*/ number | undefined;
 };
 /**
  * Generated factory for {@link SparkConfig} record objects.
@@ -6352,10 +6517,34 @@ export type TurnkeyConfig = {
      * either backend.
      */
     accountNumber: /*u32*/ number | undefined;
+    /**
+     * The wallet's identity public key (compressed, hex), to skip fetching it
+     * from Turnkey on init. Obtain it once from a freshly-built signer via
+     * [`ExternalSparkSigner::get_identity_public_key`] — the simplest source,
+     * available right after `create_turnkey_signer` with no separate connect —
+     * or, if you only have a connected SDK, from `identity_pubkey` on the
+     * get-info response. Pass it back on later inits: the signer then serves the
+     * identity key and its Spark address from this value instead of the per-init
+     * Turnkey round-trips, making signer setup network-free. Unset fetches
+     * lazily, as before. It is a stable, non-secret, per-wallet value; a value
+     * that does not match the wallet yields a signer that signs with the wrong
+     * identity, so only pass one read from this same wallet.
+     *
+     * [`ExternalSparkSigner::get_identity_public_key`]: crate::signer::ExternalSparkSigner::get_identity_public_key
+     */
+    identityPublicKey: string | undefined;
     /**
      * Retry policy for Turnkey requests. Unset uses the default policy.
      */
     retry: TurnkeyRetryConfig | undefined;
+    /**
+     * Maximum requests per second the client issues to this suborganization,
+     * across all concurrent operations. The client paces itself to this rate.
+     * Unset uses Turnkey's documented per-suborganization cap of 10 RPS; set it
+     * to the account's actual limit if a different one is provisioned. Must be
+     * greater than 0 when set: 0 is rejected at connect.
+     */
+    maxRps: /*u32*/ number | undefined;
 };
 /**
  * Generated factory for {@link TurnkeyConfig} record objects.
@@ -6365,12 +6554,12 @@ export declare const TurnkeyConfig: Readonly<{
      * Create a frozen instance of {@link TurnkeyConfig}, with defaults specified
      * in Rust, in the {@link breez_sdk_spark} crate.
      */
-    create: (partial: Partial<TurnkeyConfig> & Required<Omit<TurnkeyConfig, never>>) => TurnkeyConfig;
+    create: (partial: Partial<TurnkeyConfig> & Required<Omit<TurnkeyConfig, "maxRps">>) => TurnkeyConfig;
     /**
      * Create a frozen instance of {@link TurnkeyConfig}, with defaults specified
      * in Rust, in the {@link breez_sdk_spark} crate.
      */
-    new: (partial: Partial<TurnkeyConfig> & Required<Omit<TurnkeyConfig, never>>) => TurnkeyConfig;
+    new: (partial: Partial<TurnkeyConfig> & Required<Omit<TurnkeyConfig, "maxRps">>) => TurnkeyConfig;
     /**
      * Defaults specified in the {@link breez_sdk_spark} crate.
      */
@@ -7303,6 +7492,105 @@ export declare enum BitcoinNetwork {
     Signet = 3,
     Regtest = 4
 }
+export declare enum BuildTransferPackageOptions_Tags {
+    BitcoinAddress = "BitcoinAddress",
+    Bolt11Invoice = "Bolt11Invoice"
+}
+export declare const BuildTransferPackageOptions: Readonly<{
+    instanceOf: (obj: any) => obj is BuildTransferPackageOptions;
+    BitcoinAddress: {
+        new (inner: {
+            confirmationSpeed: OnchainConfirmationSpeed;
+        }): {
+            readonly tag: BuildTransferPackageOptions_Tags.BitcoinAddress;
+            readonly inner: Readonly<{
+                confirmationSpeed: OnchainConfirmationSpeed;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BuildTransferPackageOptions";
+        };
+        "new"(inner: {
+            confirmationSpeed: OnchainConfirmationSpeed;
+        }): {
+            readonly tag: BuildTransferPackageOptions_Tags.BitcoinAddress;
+            readonly inner: Readonly<{
+                confirmationSpeed: OnchainConfirmationSpeed;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BuildTransferPackageOptions";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: BuildTransferPackageOptions_Tags.BitcoinAddress;
+            readonly inner: Readonly<{
+                confirmationSpeed: OnchainConfirmationSpeed;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BuildTransferPackageOptions";
+        };
+    };
+    Bolt11Invoice: {
+        new (inner: {
+            preferSpark: boolean;
+            /**
+             * If set, publishing the package waits up to this many seconds for the
+             * payment to complete before returning it while still pending. If unset,
+             * publishing returns immediately after initiating the payment.
+             */ completionTimeoutSecs: /*u32*/ number | undefined;
+        }): {
+            readonly tag: BuildTransferPackageOptions_Tags.Bolt11Invoice;
+            readonly inner: Readonly<{
+                preferSpark: boolean;
+                completionTimeoutSecs: /*u32*/ number | undefined;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BuildTransferPackageOptions";
+        };
+        "new"(inner: {
+            preferSpark: boolean;
+            /**
+             * If set, publishing the package waits up to this many seconds for the
+             * payment to complete before returning it while still pending. If unset,
+             * publishing returns immediately after initiating the payment.
+             */ completionTimeoutSecs: /*u32*/ number | undefined;
+        }): {
+            readonly tag: BuildTransferPackageOptions_Tags.Bolt11Invoice;
+            readonly inner: Readonly<{
+                preferSpark: boolean;
+                completionTimeoutSecs: /*u32*/ number | undefined;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BuildTransferPackageOptions";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: BuildTransferPackageOptions_Tags.Bolt11Invoice;
+            readonly inner: Readonly<{
+                preferSpark: boolean;
+                completionTimeoutSecs: /*u32*/ number | undefined;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "BuildTransferPackageOptions";
+        };
+    };
+}>;
+export type BuildTransferPackageOptions = InstanceType<(typeof BuildTransferPackageOptions)[keyof Omit<typeof BuildTransferPackageOptions, 'instanceOf'>]>;
 export declare enum BuyBitcoinRequest_Tags {
     Moonpay = "Moonpay",
     CashApp = "CashApp"
@@ -12645,140 +12933,286 @@ export declare const ProvisionalPaymentDetails: Readonly<{
     };
 }>;
 export type ProvisionalPaymentDetails = InstanceType<(typeof ProvisionalPaymentDetails)[keyof Omit<typeof ProvisionalPaymentDetails, 'instanceOf'>]>;
-export declare enum ReceivePaymentMethod_Tags {
-    SparkAddress = "SparkAddress",
-    SparkInvoice = "SparkInvoice",
-    BitcoinAddress = "BitcoinAddress",
-    Bolt11Invoice = "Bolt11Invoice"
+export declare enum PublishSignedLnurlPayResponse_Tags {
+    SwapCompleted = "SwapCompleted",
+    PaymentSent = "PaymentSent"
 }
-export declare const ReceivePaymentMethod: Readonly<{
-    instanceOf: (obj: any) => obj is ReceivePaymentMethod;
-    SparkAddress: {
+export declare const PublishSignedLnurlPayResponse: Readonly<{
+    instanceOf: (obj: any) => obj is PublishSignedLnurlPayResponse;
+    SwapCompleted: {
         new (): {
-            readonly tag: ReceivePaymentMethod_Tags.SparkAddress;
+            readonly tag: PublishSignedLnurlPayResponse_Tags.SwapCompleted;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "ReceivePaymentMethod";
+            readonly [uniffiTypeNameSymbol]: "PublishSignedLnurlPayResponse";
         };
         "new"(): {
-            readonly tag: ReceivePaymentMethod_Tags.SparkAddress;
+            readonly tag: PublishSignedLnurlPayResponse_Tags.SwapCompleted;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "ReceivePaymentMethod";
+            readonly [uniffiTypeNameSymbol]: "PublishSignedLnurlPayResponse";
         };
         instanceOf(obj: any): obj is {
-            readonly tag: ReceivePaymentMethod_Tags.SparkAddress;
+            readonly tag: PublishSignedLnurlPayResponse_Tags.SwapCompleted;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "ReceivePaymentMethod";
+            readonly [uniffiTypeNameSymbol]: "PublishSignedLnurlPayResponse";
         };
     };
-    SparkInvoice: {
+    PaymentSent: {
         new (inner: {
-            /**
-             * Amount to receive. Denominated in sats if token identifier is empty, otherwise in the token base units
-             */ amount: U128 | undefined;
-            /**
-             * The presence of this field indicates that the payment is for a token
-             * If empty, it is a Bitcoin payment
-             */ tokenIdentifier: string | undefined;
-            /**
-             * The expiry time of the invoice as a unix timestamp in seconds
-             */ expiryTime: /*u64*/ bigint | undefined;
-            /**
-             * A description to embed in the invoice.
-             */ description: string | undefined;
-            /**
-             * If set, the invoice may only be fulfilled by a payer with this public key
-             */ senderPublicKey: string | undefined;
+            response: LnurlPayResponse;
         }): {
-            readonly tag: ReceivePaymentMethod_Tags.SparkInvoice;
+            readonly tag: PublishSignedLnurlPayResponse_Tags.PaymentSent;
             readonly inner: Readonly<{
-                amount: U128 | undefined;
-                tokenIdentifier: string | undefined;
-                expiryTime: /*u64*/ bigint | undefined;
-                description: string | undefined;
-                senderPublicKey: string | undefined;
+                response: LnurlPayResponse;
             }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "ReceivePaymentMethod";
+            readonly [uniffiTypeNameSymbol]: "PublishSignedLnurlPayResponse";
         };
         "new"(inner: {
-            /**
-             * Amount to receive. Denominated in sats if token identifier is empty, otherwise in the token base units
-             */ amount: U128 | undefined;
-            /**
-             * The presence of this field indicates that the payment is for a token
-             * If empty, it is a Bitcoin payment
-             */ tokenIdentifier: string | undefined;
-            /**
-             * The expiry time of the invoice as a unix timestamp in seconds
-             */ expiryTime: /*u64*/ bigint | undefined;
-            /**
-             * A description to embed in the invoice.
-             */ description: string | undefined;
-            /**
-             * If set, the invoice may only be fulfilled by a payer with this public key
-             */ senderPublicKey: string | undefined;
+            response: LnurlPayResponse;
         }): {
-            readonly tag: ReceivePaymentMethod_Tags.SparkInvoice;
+            readonly tag: PublishSignedLnurlPayResponse_Tags.PaymentSent;
             readonly inner: Readonly<{
-                amount: U128 | undefined;
-                tokenIdentifier: string | undefined;
-                expiryTime: /*u64*/ bigint | undefined;
-                description: string | undefined;
-                senderPublicKey: string | undefined;
+                response: LnurlPayResponse;
             }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "ReceivePaymentMethod";
+            readonly [uniffiTypeNameSymbol]: "PublishSignedLnurlPayResponse";
         };
         instanceOf(obj: any): obj is {
-            readonly tag: ReceivePaymentMethod_Tags.SparkInvoice;
+            readonly tag: PublishSignedLnurlPayResponse_Tags.PaymentSent;
             readonly inner: Readonly<{
-                amount: U128 | undefined;
-                tokenIdentifier: string | undefined;
-                expiryTime: /*u64*/ bigint | undefined;
-                description: string | undefined;
-                senderPublicKey: string | undefined;
+                response: LnurlPayResponse;
             }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "ReceivePaymentMethod";
+            readonly [uniffiTypeNameSymbol]: "PublishSignedLnurlPayResponse";
         };
     };
-    BitcoinAddress: {
-        new (inner: {
-            /**
-             * If true, rotate to a new deposit address. Previous ones remain valid.
-             * If false or absent, return the existing address (creating one if none
-             * exists yet).
-             */ newAddress: boolean | undefined;
-        }): {
-            readonly tag: ReceivePaymentMethod_Tags.BitcoinAddress;
-            readonly inner: Readonly<{
-                newAddress: boolean | undefined;
-            }>;
+}>;
+export type PublishSignedLnurlPayResponse = InstanceType<(typeof PublishSignedLnurlPayResponse)[keyof Omit<typeof PublishSignedLnurlPayResponse, 'instanceOf'>]>;
+export declare enum PublishSignedTransferPackageResponse_Tags {
+    SwapCompleted = "SwapCompleted",
+    PaymentSent = "PaymentSent"
+}
+export declare const PublishSignedTransferPackageResponse: Readonly<{
+    instanceOf: (obj: any) => obj is PublishSignedTransferPackageResponse;
+    SwapCompleted: {
+        new (): {
+            readonly tag: PublishSignedTransferPackageResponse_Tags.SwapCompleted;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "ReceivePaymentMethod";
+            readonly [uniffiTypeNameSymbol]: "PublishSignedTransferPackageResponse";
         };
-        "new"(inner: {
+        "new"(): {
+            readonly tag: PublishSignedTransferPackageResponse_Tags.SwapCompleted;
+            /**
+             * @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.SwapCompleted;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "PublishSignedTransferPackageResponse";
+        };
+    };
+    PaymentSent: {
+        new (inner: {
+            payment: Payment;
+        }): {
+            readonly tag: PublishSignedTransferPackageResponse_Tags.PaymentSent;
+            readonly inner: Readonly<{
+                payment: Payment;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "PublishSignedTransferPackageResponse";
+        };
+        "new"(inner: {
+            payment: Payment;
+        }): {
+            readonly tag: PublishSignedTransferPackageResponse_Tags.PaymentSent;
+            readonly inner: Readonly<{
+                payment: 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.PaymentSent;
+            readonly inner: Readonly<{
+                payment: 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 {
+    SparkAddress = "SparkAddress",
+    SparkInvoice = "SparkInvoice",
+    BitcoinAddress = "BitcoinAddress",
+    Bolt11Invoice = "Bolt11Invoice"
+}
+export declare const ReceivePaymentMethod: Readonly<{
+    instanceOf: (obj: any) => obj is ReceivePaymentMethod;
+    SparkAddress: {
+        new (): {
+            readonly tag: ReceivePaymentMethod_Tags.SparkAddress;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ReceivePaymentMethod";
+        };
+        "new"(): {
+            readonly tag: ReceivePaymentMethod_Tags.SparkAddress;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ReceivePaymentMethod";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ReceivePaymentMethod_Tags.SparkAddress;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ReceivePaymentMethod";
+        };
+    };
+    SparkInvoice: {
+        new (inner: {
+            /**
+             * Amount to receive. Denominated in sats if token identifier is empty, otherwise in the token base units
+             */ amount: U128 | undefined;
+            /**
+             * The presence of this field indicates that the payment is for a token
+             * If empty, it is a Bitcoin payment
+             */ tokenIdentifier: string | undefined;
+            /**
+             * The expiry time of the invoice as a unix timestamp in seconds
+             */ expiryTime: /*u64*/ bigint | undefined;
+            /**
+             * A description to embed in the invoice.
+             */ description: string | undefined;
+            /**
+             * If set, the invoice may only be fulfilled by a payer with this public key
+             */ senderPublicKey: string | undefined;
+        }): {
+            readonly tag: ReceivePaymentMethod_Tags.SparkInvoice;
+            readonly inner: Readonly<{
+                amount: U128 | undefined;
+                tokenIdentifier: string | undefined;
+                expiryTime: /*u64*/ bigint | undefined;
+                description: string | undefined;
+                senderPublicKey: string | undefined;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ReceivePaymentMethod";
+        };
+        "new"(inner: {
+            /**
+             * Amount to receive. Denominated in sats if token identifier is empty, otherwise in the token base units
+             */ amount: U128 | undefined;
+            /**
+             * The presence of this field indicates that the payment is for a token
+             * If empty, it is a Bitcoin payment
+             */ tokenIdentifier: string | undefined;
+            /**
+             * The expiry time of the invoice as a unix timestamp in seconds
+             */ expiryTime: /*u64*/ bigint | undefined;
+            /**
+             * A description to embed in the invoice.
+             */ description: string | undefined;
+            /**
+             * If set, the invoice may only be fulfilled by a payer with this public key
+             */ senderPublicKey: string | undefined;
+        }): {
+            readonly tag: ReceivePaymentMethod_Tags.SparkInvoice;
+            readonly inner: Readonly<{
+                amount: U128 | undefined;
+                tokenIdentifier: string | undefined;
+                expiryTime: /*u64*/ bigint | undefined;
+                description: string | undefined;
+                senderPublicKey: string | undefined;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ReceivePaymentMethod";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ReceivePaymentMethod_Tags.SparkInvoice;
+            readonly inner: Readonly<{
+                amount: U128 | undefined;
+                tokenIdentifier: string | undefined;
+                expiryTime: /*u64*/ bigint | undefined;
+                description: string | undefined;
+                senderPublicKey: string | undefined;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ReceivePaymentMethod";
+        };
+    };
+    BitcoinAddress: {
+        new (inner: {
+            /**
+             * If true, rotate to a new deposit address. Previous ones remain valid.
+             * If false or absent, return the existing address (creating one if none
+             * exists yet).
+             */ newAddress: boolean | undefined;
+        }): {
+            readonly tag: ReceivePaymentMethod_Tags.BitcoinAddress;
+            readonly inner: Readonly<{
+                newAddress: boolean | undefined;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ReceivePaymentMethod";
+        };
+        "new"(inner: {
             /**
              * If true, rotate to a new deposit address. Previous ones remain valid.
              * If false or absent, return the existing address (creating one if none
@@ -17361,6 +17795,437 @@ export declare enum TokenTransactionType {
     Mint = 1,
     Burn = 2
 }
+export declare enum TransferSignature_Tags {
+    Transfer = "Transfer",
+    Token = "Token"
+}
+export declare const TransferSignature: Readonly<{
+    instanceOf: (obj: any) => obj is TransferSignature;
+    Transfer: {
+        new (inner: {
+            signed: ExternalPreparedTransfer;
+        }): {
+            readonly tag: TransferSignature_Tags.Transfer;
+            readonly inner: Readonly<{
+                signed: ExternalPreparedTransfer;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "TransferSignature";
+        };
+        "new"(inner: {
+            signed: ExternalPreparedTransfer;
+        }): {
+            readonly tag: TransferSignature_Tags.Transfer;
+            readonly inner: Readonly<{
+                signed: ExternalPreparedTransfer;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "TransferSignature";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: TransferSignature_Tags.Transfer;
+            readonly inner: Readonly<{
+                signed: ExternalPreparedTransfer;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "TransferSignature";
+        };
+    };
+    Token: {
+        new (inner: {
+            signed: ExternalPreparedTokenTransaction;
+        }): {
+            readonly tag: TransferSignature_Tags.Token;
+            readonly inner: Readonly<{
+                signed: ExternalPreparedTokenTransaction;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "TransferSignature";
+        };
+        "new"(inner: {
+            signed: ExternalPreparedTokenTransaction;
+        }): {
+            readonly tag: TransferSignature_Tags.Token;
+            readonly inner: Readonly<{
+                signed: ExternalPreparedTokenTransaction;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "TransferSignature";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: TransferSignature_Tags.Token;
+            readonly inner: Readonly<{
+                signed: ExternalPreparedTokenTransaction;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "TransferSignature";
+        };
+    };
+}>;
+export type TransferSignature = InstanceType<(typeof TransferSignature)[keyof Omit<typeof TransferSignature, 'instanceOf'>]>;
+export declare enum TransferTarget_Tags {
+    Spark = "Spark",
+    Lightning = "Lightning",
+    CoopExit = "CoopExit"
+}
+export declare const TransferTarget: Readonly<{
+    instanceOf: (obj: any) => obj is TransferTarget;
+    Spark: {
+        new (inner: {
+            address: string;
+            sparkInvoice: string | undefined;
+        }): {
+            readonly tag: TransferTarget_Tags.Spark;
+            readonly inner: Readonly<{
+                address: string;
+                sparkInvoice: string | undefined;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "TransferTarget";
+        };
+        "new"(inner: {
+            address: string;
+            sparkInvoice: string | undefined;
+        }): {
+            readonly tag: TransferTarget_Tags.Spark;
+            readonly inner: Readonly<{
+                address: string;
+                sparkInvoice: string | undefined;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "TransferTarget";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: TransferTarget_Tags.Spark;
+            readonly inner: Readonly<{
+                address: string;
+                sparkInvoice: string | undefined;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "TransferTarget";
+        };
+    };
+    Lightning: {
+        new (inner: {
+            bolt11: string;
+            lnurlPay: LnurlPayContext | undefined;
+            feePolicy: FeePolicy;
+            completionTimeoutSecs: /*u32*/ number | undefined;
+        }): {
+            readonly tag: TransferTarget_Tags.Lightning;
+            readonly inner: Readonly<{
+                bolt11: string;
+                lnurlPay: LnurlPayContext | undefined;
+                feePolicy: FeePolicy;
+                completionTimeoutSecs: /*u32*/ number | undefined;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "TransferTarget";
+        };
+        "new"(inner: {
+            bolt11: string;
+            lnurlPay: LnurlPayContext | undefined;
+            feePolicy: FeePolicy;
+            completionTimeoutSecs: /*u32*/ number | undefined;
+        }): {
+            readonly tag: TransferTarget_Tags.Lightning;
+            readonly inner: Readonly<{
+                bolt11: string;
+                lnurlPay: LnurlPayContext | undefined;
+                feePolicy: FeePolicy;
+                completionTimeoutSecs: /*u32*/ number | undefined;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "TransferTarget";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: TransferTarget_Tags.Lightning;
+            readonly inner: Readonly<{
+                bolt11: string;
+                lnurlPay: LnurlPayContext | undefined;
+                feePolicy: FeePolicy;
+                completionTimeoutSecs: /*u32*/ number | undefined;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "TransferTarget";
+        };
+    };
+    CoopExit: {
+        new (inner: {
+            address: string;
+            feeQuote: SendOnchainFeeQuote;
+            confirmationSpeed: OnchainConfirmationSpeed;
+        }): {
+            readonly tag: TransferTarget_Tags.CoopExit;
+            readonly inner: Readonly<{
+                address: string;
+                feeQuote: SendOnchainFeeQuote;
+                confirmationSpeed: OnchainConfirmationSpeed;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "TransferTarget";
+        };
+        "new"(inner: {
+            address: string;
+            feeQuote: SendOnchainFeeQuote;
+            confirmationSpeed: OnchainConfirmationSpeed;
+        }): {
+            readonly tag: TransferTarget_Tags.CoopExit;
+            readonly inner: Readonly<{
+                address: string;
+                feeQuote: SendOnchainFeeQuote;
+                confirmationSpeed: OnchainConfirmationSpeed;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "TransferTarget";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: TransferTarget_Tags.CoopExit;
+            readonly inner: Readonly<{
+                address: string;
+                feeQuote: SendOnchainFeeQuote;
+                confirmationSpeed: OnchainConfirmationSpeed;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "TransferTarget";
+        };
+    };
+}>;
+export type TransferTarget = InstanceType<(typeof TransferTarget)[keyof Omit<typeof TransferTarget, 'instanceOf'>]>;
+export declare enum UnsignedTransferPackage_Tags {
+    Swap = "Swap",
+    Transfer = "Transfer",
+    Token = "Token"
+}
+export declare const UnsignedTransferPackage: Readonly<{
+    instanceOf: (obj: any) => obj is UnsignedTransferPackage;
+    Swap: {
+        new (inner: {
+            prepareTransfer: ExternalPrepareTransferRequest;
+            targetAmounts: Array</*u64*/ bigint>;
+            amountSat: bigint;
+            feeSat: bigint;
+        }): {
+            readonly tag: UnsignedTransferPackage_Tags.Swap;
+            readonly inner: Readonly<{
+                prepareTransfer: ExternalPrepareTransferRequest;
+                targetAmounts: Array</*u64*/ bigint>;
+                amountSat: bigint;
+                feeSat: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "UnsignedTransferPackage";
+        };
+        "new"(inner: {
+            prepareTransfer: ExternalPrepareTransferRequest;
+            targetAmounts: Array</*u64*/ bigint>;
+            amountSat: bigint;
+            feeSat: bigint;
+        }): {
+            readonly tag: UnsignedTransferPackage_Tags.Swap;
+            readonly inner: Readonly<{
+                prepareTransfer: ExternalPrepareTransferRequest;
+                targetAmounts: Array</*u64*/ bigint>;
+                amountSat: bigint;
+                feeSat: bigint;
+            }>;
+            /**
+             * @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.Swap;
+            readonly inner: Readonly<{
+                prepareTransfer: ExternalPrepareTransferRequest;
+                targetAmounts: Array</*u64*/ bigint>;
+                amountSat: bigint;
+                feeSat: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "UnsignedTransferPackage";
+        };
+    };
+    Transfer: {
+        new (inner: {
+            prepareTransfer: ExternalPrepareTransferRequest;
+            amountSat: bigint;
+            feeSat: bigint;
+            target: TransferTarget;
+        }): {
+            readonly tag: UnsignedTransferPackage_Tags.Transfer;
+            readonly inner: Readonly<{
+                prepareTransfer: ExternalPrepareTransferRequest;
+                amountSat: bigint;
+                feeSat: bigint;
+                target: TransferTarget;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "UnsignedTransferPackage";
+        };
+        "new"(inner: {
+            prepareTransfer: ExternalPrepareTransferRequest;
+            amountSat: bigint;
+            feeSat: bigint;
+            target: TransferTarget;
+        }): {
+            readonly tag: UnsignedTransferPackage_Tags.Transfer;
+            readonly inner: Readonly<{
+                prepareTransfer: ExternalPrepareTransferRequest;
+                amountSat: bigint;
+                feeSat: bigint;
+                target: TransferTarget;
+            }>;
+            /**
+             * @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.Transfer;
+            readonly inner: Readonly<{
+                prepareTransfer: ExternalPrepareTransferRequest;
+                amountSat: bigint;
+                feeSat: bigint;
+                target: TransferTarget;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "UnsignedTransferPackage";
+        };
+    };
+    Token: {
+        new (inner: {
+            prepareTokenTransaction: ExternalPrepareTokenTransactionRequest;
+            tokenContext: ArrayBuffer;
+            tokenIdentifier: string;
+            amount: U128;
+            fee: U128;
+            /**
+             * 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.Token;
+            readonly inner: Readonly<{
+                prepareTokenTransaction: ExternalPrepareTokenTransactionRequest;
+                tokenContext: ArrayBuffer;
+                tokenIdentifier: string;
+                amount: U128;
+                fee: U128;
+                isSwap: boolean;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "UnsignedTransferPackage";
+        };
+        "new"(inner: {
+            prepareTokenTransaction: ExternalPrepareTokenTransactionRequest;
+            tokenContext: ArrayBuffer;
+            tokenIdentifier: string;
+            amount: U128;
+            fee: U128;
+            /**
+             * 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.Token;
+            readonly inner: Readonly<{
+                prepareTokenTransaction: ExternalPrepareTokenTransactionRequest;
+                tokenContext: ArrayBuffer;
+                tokenIdentifier: string;
+                amount: U128;
+                fee: U128;
+                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.Token;
+            readonly inner: Readonly<{
+                prepareTokenTransaction: ExternalPrepareTokenTransactionRequest;
+                tokenContext: ArrayBuffer;
+                tokenIdentifier: string;
+                amount: U128;
+                fee: U128;
+                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 {
     ClaimError = "ClaimError",
     Refund = "Refund"
@@ -17693,6 +18558,12 @@ export interface BreezSdkInterface {
     authorizeLightningAddressTransfer(request: AuthorizeTransferRequest, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<TransferAuthorization>;
+    buildUnsignedLnurlPayPackage(request: BuildUnsignedLnurlPayPackageRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<UnsignedTransferPackage>;
+    buildUnsignedTransferPackage(request: BuildUnsignedTransferPackageRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<UnsignedTransferPackage>;
     /**
      * Initiates a Bitcoin purchase flow via an external provider.
      *
@@ -17945,6 +18816,12 @@ export interface BreezSdkInterface {
     prepareSendPayment(request: PrepareSendPaymentRequest, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<PrepareSendPaymentResponse>;
+    publishSignedLnurlPayPackage(request: PublishSignedLnurlPayPackageRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<PublishSignedLnurlPayResponse>;
+    publishSignedTransferPackage(request: PublishSignedTransferPackageRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<PublishSignedTransferPackageResponse>;
     receivePayment(request: ReceivePaymentRequest, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<ReceivePaymentResponse>;
@@ -18111,6 +18988,12 @@ export declare class BreezSdk extends UniffiAbstractObject implements BreezSdkIn
     authorizeLightningAddressTransfer(request: AuthorizeTransferRequest, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<TransferAuthorization>;
+    buildUnsignedLnurlPayPackage(request: BuildUnsignedLnurlPayPackageRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<UnsignedTransferPackage>;
+    buildUnsignedTransferPackage(request: BuildUnsignedTransferPackageRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<UnsignedTransferPackage>;
     /**
      * Initiates a Bitcoin purchase flow via an external provider.
      *
@@ -18363,6 +19246,12 @@ export declare class BreezSdk extends UniffiAbstractObject implements BreezSdkIn
     prepareSendPayment(request: PrepareSendPaymentRequest, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<PrepareSendPaymentResponse>;
+    publishSignedLnurlPayPackage(request: PublishSignedLnurlPayPackageRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<PublishSignedLnurlPayResponse>;
+    publishSignedTransferPackage(request: PublishSignedTransferPackageRequest, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<PublishSignedTransferPackageResponse>;
     receivePayment(request: ReceivePaymentRequest, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<ReceivePaymentResponse>;
@@ -18882,6 +19771,13 @@ export interface ExternalSparkSigner {
     getPublicKeyForLeaf(leafId: ExternalTreeNodeId, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<PublicKeyBytes>;
+    /**
+     * Whether this signer is backed by a remote service, so its operations are
+     * network round-trips rather than local computation. Local signers return
+     * false; a hosted signer like Turnkey returns true so the SDK can avoid
+     * redundant calls, e.g. re-deriving keys for leaves it has already verified.
+     */
+    isRemote(): boolean;
     /**
      * The static-deposit signing public key at `index`.
      */
@@ -18981,6 +19877,13 @@ export declare class ExternalSparkSignerImpl extends UniffiAbstractObject implem
     getPublicKeyForLeaf(leafId: ExternalTreeNodeId, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<PublicKeyBytes>;
+    /**
+     * Whether this signer is backed by a remote service, so its operations are
+     * network round-trips rather than local computation. Local signers return
+     * false; a hosted signer like Turnkey returns true so the SDK can avoid
+     * redundant calls, e.g. re-deriving keys for leaves it has already verified.
+     */
+    isRemote(): boolean;
     /**
      * The static-deposit signing public key at `index`.
      */
@@ -19137,8 +20040,7 @@ export interface PasskeyClientInterface {
     }): Promise<PasskeyAvailability>;
     /**
      * Single-CTA onboarding: silent sign-in, falling through to
-     * registration when no credential exists on the device. The returned
-     * [`ConnectFlow`] tells the caller which path ran.
+     * registration when no credential exists on the device.
      *
      * The silent sign-in pins `prefer_immediately_available_credentials =
      * true` regardless of [`SignInRequest`]: the fallback depends on the OS
@@ -19147,11 +20049,12 @@ export interface PasskeyClientInterface {
      * register path; every other error (`Cancel`, `Timeout`, ...) propagates
      * unchanged.
      *
-     * Mobile-only: meant for iOS 18+ / Android 9+ where
-     * `preferImmediatelyAvailableCredentials` is honored. The web
-     * equivalent (`mediation: 'immediate'`) is not yet stable
-     * cross-browser, so this is not surfaced on WASM; web hosts call
-     * [`Self::sign_in`] and catch `CredentialNotFound` themselves.
+     * On WASM the silent sign-in maps to `WebAuthn` `uiMode: 'immediate'`
+     * where the browser advertises it. Web hosts gate on the browser's
+     * immediate-mediation capability (the WASM client surfaces it):
+     * without it the probe shows the standard picker and a dismiss is a
+     * cancel, not `CredentialNotFound`, so it never reaches register.
+     * Present an explicit create / sign-in choice there instead.
      */
     connectWithPasskey(request: ConnectWithPasskeyRequest, asyncOpts_?: {
         signal: AbortSignal;
@@ -19216,8 +20119,7 @@ export declare class PasskeyClient extends UniffiAbstractObject implements Passk
     }): Promise<PasskeyAvailability>;
     /**
      * Single-CTA onboarding: silent sign-in, falling through to
-     * registration when no credential exists on the device. The returned
-     * [`ConnectFlow`] tells the caller which path ran.
+     * registration when no credential exists on the device.
      *
      * The silent sign-in pins `prefer_immediately_available_credentials =
      * true` regardless of [`SignInRequest`]: the fallback depends on the OS
@@ -19226,11 +20128,12 @@ export declare class PasskeyClient extends UniffiAbstractObject implements Passk
      * register path; every other error (`Cancel`, `Timeout`, ...) propagates
      * unchanged.
      *
-     * Mobile-only: meant for iOS 18+ / Android 9+ where
-     * `preferImmediatelyAvailableCredentials` is honored. The web
-     * equivalent (`mediation: 'immediate'`) is not yet stable
-     * cross-browser, so this is not surfaced on WASM; web hosts call
-     * [`Self::sign_in`] and catch `CredentialNotFound` themselves.
+     * On WASM the silent sign-in maps to `WebAuthn` `uiMode: 'immediate'`
+     * where the browser advertises it. Web hosts gate on the browser's
+     * immediate-mediation capability (the WASM client surfaces it):
+     * without it the probe shows the standard picker and a dismiss is a
+     * cancel, not `CredentialNotFound`, so it never reaches register.
+     * Present an explicit create / sign-in choice there instead.
      */
     connectWithPasskey(request: ConnectWithPasskeyRequest, asyncOpts_?: {
         signal: AbortSignal;
@@ -19681,6 +20584,18 @@ export interface SdkBuilderInterface {
     withRestChainService(url: string, apiType: ChainApiType, credentials: Credentials | undefined, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<void>;
+    /**
+     * Overrides the session store used to cache auth tokens, replacing the one
+     * the backend provides. Supply any [`SessionStore`]: for example one that
+     * wraps the backend's own store (from
+     * [`default_session_store`](crate::default_session_store)) to add at-rest
+     * encryption, which the SDK does not apply itself.
+     * Arguments:
+     * - `session_store`: The session store to use in place of the backend's.
+     */
+    withSessionStore(sessionStore: SessionStore, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
     /**
      * Threads a shared [`SdkContext`](crate::SdkContext) into the builder.
      *
@@ -19820,6 +20735,18 @@ export declare class SdkBuilder extends UniffiAbstractObject implements SdkBuild
     withRestChainService(url: string, apiType: ChainApiType, credentials: Credentials | undefined, asyncOpts_?: {
         signal: AbortSignal;
     }): Promise<void>;
+    /**
+     * Overrides the session store used to cache auth tokens, replacing the one
+     * the backend provides. Supply any [`SessionStore`]: for example one that
+     * wraps the backend's own store (from
+     * [`default_session_store`](crate::default_session_store)) to add at-rest
+     * encryption, which the SDK does not apply itself.
+     * Arguments:
+     * - `session_store`: The session store to use in place of the backend's.
+     */
+    withSessionStore(sessionStore: SessionStore, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
     /**
      * Threads a shared [`SdkContext`](crate::SdkContext) into the builder.
      *
@@ -20883,6 +21810,27 @@ declare const _default: Readonly<{
             lower(value: Bolt12OfferDetails): UniffiByteArray;
         };
         FfiConverterTypeBreezSdk: FfiConverterObject<BreezSdkInterface>;
+        FfiConverterTypeBuildTransferPackageOptions: {
+            read(from: RustBuffer): BuildTransferPackageOptions;
+            write(value: BuildTransferPackageOptions, into: RustBuffer): void;
+            allocationSize(value: BuildTransferPackageOptions): number;
+            lift(value: UniffiByteArray): BuildTransferPackageOptions;
+            lower(value: BuildTransferPackageOptions): UniffiByteArray;
+        };
+        FfiConverterTypeBuildUnsignedLnurlPayPackageRequest: {
+            read(from: RustBuffer): BuildUnsignedLnurlPayPackageRequest;
+            write(value: BuildUnsignedLnurlPayPackageRequest, into: RustBuffer): void;
+            allocationSize(value: BuildUnsignedLnurlPayPackageRequest): number;
+            lift(value: UniffiByteArray): BuildUnsignedLnurlPayPackageRequest;
+            lower(value: BuildUnsignedLnurlPayPackageRequest): UniffiByteArray;
+        };
+        FfiConverterTypeBuildUnsignedTransferPackageRequest: {
+            read(from: RustBuffer): BuildUnsignedTransferPackageRequest;
+            write(value: BuildUnsignedTransferPackageRequest, into: RustBuffer): void;
+            allocationSize(value: BuildUnsignedTransferPackageRequest): number;
+            lift(value: UniffiByteArray): BuildUnsignedTransferPackageRequest;
+            lower(value: BuildUnsignedTransferPackageRequest): UniffiByteArray;
+        };
         FfiConverterTypeBurnIssuerTokenRequest: {
             read(from: RustBuffer): BurnIssuerTokenRequest;
             write(value: BurnIssuerTokenRequest, into: RustBuffer): void;
@@ -21720,6 +22668,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): LnurlInfo;
             lower(value: LnurlInfo): UniffiByteArray;
         };
+        FfiConverterTypeLnurlPayContext: {
+            read(from: RustBuffer): LnurlPayContext;
+            write(value: LnurlPayContext, into: RustBuffer): void;
+            allocationSize(value: LnurlPayContext): number;
+            lift(value: UniffiByteArray): LnurlPayContext;
+            lower(value: LnurlPayContext): UniffiByteArray;
+        };
         FfiConverterTypeLnurlPayInfo: {
             read(from: RustBuffer): LnurlPayInfo;
             write(value: LnurlPayInfo, into: RustBuffer): void;
@@ -22054,6 +23009,34 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): PublicKeyBytes;
             lower(value: PublicKeyBytes): UniffiByteArray;
         };
+        FfiConverterTypePublishSignedLnurlPayPackageRequest: {
+            read(from: RustBuffer): PublishSignedLnurlPayPackageRequest;
+            write(value: PublishSignedLnurlPayPackageRequest, into: RustBuffer): void;
+            allocationSize(value: PublishSignedLnurlPayPackageRequest): number;
+            lift(value: UniffiByteArray): PublishSignedLnurlPayPackageRequest;
+            lower(value: PublishSignedLnurlPayPackageRequest): UniffiByteArray;
+        };
+        FfiConverterTypePublishSignedLnurlPayResponse: {
+            read(from: RustBuffer): PublishSignedLnurlPayResponse;
+            write(value: PublishSignedLnurlPayResponse, into: RustBuffer): void;
+            allocationSize(value: PublishSignedLnurlPayResponse): number;
+            lift(value: UniffiByteArray): PublishSignedLnurlPayResponse;
+            lower(value: PublishSignedLnurlPayResponse): UniffiByteArray;
+        };
+        FfiConverterTypePublishSignedTransferPackageRequest: {
+            read(from: RustBuffer): PublishSignedTransferPackageRequest;
+            write(value: PublishSignedTransferPackageRequest, into: RustBuffer): void;
+            allocationSize(value: PublishSignedTransferPackageRequest): number;
+            lift(value: UniffiByteArray): PublishSignedTransferPackageRequest;
+            lower(value: PublishSignedTransferPackageRequest): UniffiByteArray;
+        };
+        FfiConverterTypePublishSignedTransferPackageResponse: {
+            read(from: RustBuffer): PublishSignedTransferPackageResponse;
+            write(value: PublishSignedTransferPackageResponse, into: RustBuffer): void;
+            allocationSize(value: PublishSignedTransferPackageResponse): number;
+            lift(value: UniffiByteArray): PublishSignedTransferPackageResponse;
+            lower(value: PublishSignedTransferPackageResponse): UniffiByteArray;
+        };
         FfiConverterTypeRate: {
             read(from: RustBuffer): Rate;
             write(value: Rate, into: RustBuffer): void;
@@ -22332,6 +23315,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): SignMessageResponse;
             lower(value: SignMessageResponse): UniffiByteArray;
         };
+        FfiConverterTypeSignedTransferPackage: {
+            read(from: RustBuffer): SignedTransferPackage;
+            write(value: SignedTransferPackage, into: RustBuffer): void;
+            allocationSize(value: SignedTransferPackage): number;
+            lift(value: UniffiByteArray): SignedTransferPackage;
+            lower(value: SignedTransferPackage): UniffiByteArray;
+        };
         FfiConverterTypeSignerError: {
             read(from: RustBuffer): SignerError;
             write(value: SignerError, into: RustBuffer): void;
@@ -22552,6 +23542,20 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): TransferAuthorization;
             lower(value: TransferAuthorization): UniffiByteArray;
         };
+        FfiConverterTypeTransferSignature: {
+            read(from: RustBuffer): TransferSignature;
+            write(value: TransferSignature, into: RustBuffer): void;
+            allocationSize(value: TransferSignature): number;
+            lift(value: UniffiByteArray): TransferSignature;
+            lower(value: TransferSignature): UniffiByteArray;
+        };
+        FfiConverterTypeTransferTarget: {
+            read(from: RustBuffer): TransferTarget;
+            write(value: TransferTarget, into: RustBuffer): void;
+            allocationSize(value: TransferTarget): number;
+            lift(value: UniffiByteArray): TransferTarget;
+            lower(value: TransferTarget): UniffiByteArray;
+        };
         FfiConverterTypeTurnkeyConfig: {
             read(from: RustBuffer): TurnkeyConfig;
             write(value: TurnkeyConfig, into: RustBuffer): void;
@@ -22594,6 +23598,13 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): UnregisterWebhookRequest;
             lower(value: UnregisterWebhookRequest): UniffiByteArray;
         };
+        FfiConverterTypeUnsignedTransferPackage: {
+            read(from: RustBuffer): UnsignedTransferPackage;
+            write(value: UnsignedTransferPackage, into: RustBuffer): void;
+            allocationSize(value: UnsignedTransferPackage): number;
+            lift(value: UniffiByteArray): UnsignedTransferPackage;
+            lower(value: UnsignedTransferPackage): UniffiByteArray;
+        };
         FfiConverterTypeUnversionedRecordChange: {
             read(from: RustBuffer): UnversionedRecordChange;
             write(value: UnversionedRecordChange, into: RustBuffer): void;