@xstoicunicornx/payjoin_test 0.1.6 → 0.1.8

package/dist/{generated/payjoin_ffi.d.ts → nodejs/bindings/payjoin.d.ts}

@@ -1,30 +1,155 @@
-import { type AddressInterface, type OutPoint, type PsbtInterface, type ScriptInterface, type TransactionInterface, type TxIn, type TxOut } from "./bitcoin";
 import { type UniffiByteArray, type UniffiRustArcPtr, type UnsafeMutableRawPointer, FfiConverterObject, FfiConverterObjectAsError, FfiConverterObjectWithCallbacks, RustBuffer, UniffiAbstractObject, UniffiThrownObject, destructorGuardSymbol, pointerLiteralSymbol, uniffiTypeNameSymbol } from "uniffi-bindgen-react-native";
 export declare function replayReceiverEventLog(persister: JsonReceiverSessionPersister): ReplayResultInterface;
+export declare function replayReceiverEventLogAsync(persister: JsonReceiverSessionPersisterAsync, asyncOpts_?: {
+    signal: AbortSignal;
+}): Promise<ReplayResultInterface>;
 export declare function replaySenderEventLog(persister: JsonSenderSessionPersister): SenderReplayResultInterface;
-export type PsbtInput = {
-    witnessUtxo: TxOut | undefined;
-    redeemScript: ScriptInterface | undefined;
-    witnessScript: ScriptInterface | undefined;
+export declare function replaySenderEventLogAsync(persister: JsonSenderSessionPersisterAsync, asyncOpts_?: {
+    signal: AbortSignal;
+}): Promise<SenderReplayResultInterface>;
+/**
+ * Primitive representation of an outpoint for the FFI boundary.
+ */
+export type PlainOutPoint = {
+    /**
+     * Hex-encoded txid (big-endian).
+     */
+    txid: string;
+    /**
+     * Output index.
+     */
+    vout: number;
+};
+/**
+ * Generated factory for {@link PlainOutPoint} record objects.
+ */
+export declare const PlainOutPoint: Readonly<{
+    /**
+     * Create a frozen instance of {@link PlainOutPoint}, with defaults specified
+     * in Rust, in the {@link payjoin} crate.
+     */
+    create: (partial: Partial<PlainOutPoint> & Required<Omit<PlainOutPoint, never>>) => PlainOutPoint;
+    /**
+     * Create a frozen instance of {@link PlainOutPoint}, with defaults specified
+     * in Rust, in the {@link payjoin} crate.
+     */
+    new: (partial: Partial<PlainOutPoint> & Required<Omit<PlainOutPoint, never>>) => PlainOutPoint;
+    /**
+     * Defaults specified in the {@link payjoin} crate.
+     */
+    defaults: () => Partial<PlainOutPoint>;
+}>;
+/**
+ * Primitive representation of a PSBT input for the FFI boundary.
+ */
+export type PlainPsbtInput = {
+    witnessUtxo: PlainTxOut | undefined;
+    redeemScript: ArrayBuffer | undefined;
+    witnessScript: ArrayBuffer | undefined;
+};
+/**
+ * Generated factory for {@link PlainPsbtInput} record objects.
+ */
+export declare const PlainPsbtInput: Readonly<{
+    /**
+     * Create a frozen instance of {@link PlainPsbtInput}, with defaults specified
+     * in Rust, in the {@link payjoin} crate.
+     */
+    create: (partial: Partial<PlainPsbtInput> & Required<Omit<PlainPsbtInput, never>>) => PlainPsbtInput;
+    /**
+     * Create a frozen instance of {@link PlainPsbtInput}, with defaults specified
+     * in Rust, in the {@link payjoin} crate.
+     */
+    new: (partial: Partial<PlainPsbtInput> & Required<Omit<PlainPsbtInput, never>>) => PlainPsbtInput;
+    /**
+     * Defaults specified in the {@link payjoin} crate.
+     */
+    defaults: () => Partial<PlainPsbtInput>;
+}>;
+/**
+ * Primitive representation of a transaction input for the FFI boundary.
+ */
+export type PlainTxIn = {
+    previousOutput: PlainOutPoint;
+    scriptSig: ArrayBuffer;
+    sequence: number;
+    witness: Array<ArrayBuffer>;
+};
+/**
+ * Generated factory for {@link PlainTxIn} record objects.
+ */
+export declare const PlainTxIn: Readonly<{
+    /**
+     * Create a frozen instance of {@link PlainTxIn}, with defaults specified
+     * in Rust, in the {@link payjoin} crate.
+     */
+    create: (partial: Partial<PlainTxIn> & Required<Omit<PlainTxIn, never>>) => PlainTxIn;
+    /**
+     * Create a frozen instance of {@link PlainTxIn}, with defaults specified
+     * in Rust, in the {@link payjoin} crate.
+     */
+    new: (partial: Partial<PlainTxIn> & Required<Omit<PlainTxIn, never>>) => PlainTxIn;
+    /**
+     * Defaults specified in the {@link payjoin} crate.
+     */
+    defaults: () => Partial<PlainTxIn>;
+}>;
+/**
+ * Primitive representation of a transaction output for the FFI boundary.
+ */
+export type PlainTxOut = {
+    /**
+     * Amount in satoshis.
+     */
+    valueSat: bigint;
+    /**
+     * Raw scriptPubKey bytes.
+     */
+    scriptPubkey: ArrayBuffer;
+};
+/**
+ * Generated factory for {@link PlainTxOut} record objects.
+ */
+export declare const PlainTxOut: Readonly<{
+    /**
+     * Create a frozen instance of {@link PlainTxOut}, with defaults specified
+     * in Rust, in the {@link payjoin} crate.
+     */
+    create: (partial: Partial<PlainTxOut> & Required<Omit<PlainTxOut, never>>) => PlainTxOut;
+    /**
+     * Create a frozen instance of {@link PlainTxOut}, with defaults specified
+     * in Rust, in the {@link payjoin} crate.
+     */
+    new: (partial: Partial<PlainTxOut> & Required<Omit<PlainTxOut, never>>) => PlainTxOut;
+    /**
+     * Defaults specified in the {@link payjoin} crate.
+     */
+    defaults: () => Partial<PlainTxOut>;
+}>;
+/**
+ * Primitive representation of a weight measurement.
+ */
+export type PlainWeight = {
+    weightUnits: bigint;
 };
 /**
- * Generated factory for {@link PsbtInput} record objects.
+ * Generated factory for {@link PlainWeight} record objects.
  */
-export declare const PsbtInput: Readonly<{
+export declare const PlainWeight: Readonly<{
     /**
-     * Create a frozen instance of {@link PsbtInput}, with defaults specified
-     * in Rust, in the {@link payjoin_ffi} crate.
+     * Create a frozen instance of {@link PlainWeight}, with defaults specified
+     * in Rust, in the {@link payjoin} crate.
      */
-    create: (partial: Partial<PsbtInput> & Required<Omit<PsbtInput, never>>) => PsbtInput;
+    create: (partial: Partial<PlainWeight> & Required<Omit<PlainWeight, never>>) => PlainWeight;
     /**
-     * Create a frozen instance of {@link PsbtInput}, with defaults specified
-     * in Rust, in the {@link payjoin_ffi} crate.
+     * Create a frozen instance of {@link PlainWeight}, with defaults specified
+     * in Rust, in the {@link payjoin} crate.
      */
-    new: (partial: Partial<PsbtInput> & Required<Omit<PsbtInput, never>>) => PsbtInput;
+    new: (partial: Partial<PlainWeight> & Required<Omit<PlainWeight, never>>) => PlainWeight;
     /**
-     * Defaults specified in the {@link payjoin_ffi} crate.
+     * Defaults specified in the {@link payjoin} crate.
      */
-    defaults: () => Partial<PsbtInput>;
+    defaults: () => Partial<PlainWeight>;
 }>;
 /**
  * Represents data that needs to be transmitted to the receiver.
@@ -56,16 +181,16 @@ export type Request = {
 export declare const Request: Readonly<{
     /**
      * Create a frozen instance of {@link Request}, with defaults specified
-     * in Rust, in the {@link payjoin_ffi} crate.
+     * in Rust, in the {@link payjoin} crate.
      */
     create: (partial: Partial<Request> & Required<Omit<Request, never>>) => Request;
     /**
      * Create a frozen instance of {@link Request}, with defaults specified
-     * in Rust, in the {@link payjoin_ffi} crate.
+     * in Rust, in the {@link payjoin} crate.
      */
     new: (partial: Partial<Request> & Required<Omit<Request, never>>) => Request;
     /**
-     * Defaults specified in the {@link payjoin_ffi} crate.
+     * Defaults specified in the {@link payjoin} crate.
      */
     defaults: () => Partial<Request>;
 }>;
@@ -79,16 +204,16 @@ export type RequestOhttpContext = {
 export declare const RequestOhttpContext: Readonly<{
     /**
      * Create a frozen instance of {@link RequestOhttpContext}, with defaults specified
-     * in Rust, in the {@link payjoin_ffi} crate.
+     * in Rust, in the {@link payjoin} crate.
      */
     create: (partial: Partial<RequestOhttpContext> & Required<Omit<RequestOhttpContext, never>>) => RequestOhttpContext;
     /**
      * Create a frozen instance of {@link RequestOhttpContext}, with defaults specified
-     * in Rust, in the {@link payjoin_ffi} crate.
+     * in Rust, in the {@link payjoin} crate.
      */
     new: (partial: Partial<RequestOhttpContext> & Required<Omit<RequestOhttpContext, never>>) => RequestOhttpContext;
     /**
-     * Defaults specified in the {@link payjoin_ffi} crate.
+     * Defaults specified in the {@link payjoin} crate.
      */
     defaults: () => Partial<RequestOhttpContext>;
 }>;
@@ -102,16 +227,16 @@ export type RequestResponse = {
 export declare const RequestResponse: Readonly<{
     /**
      * Create a frozen instance of {@link RequestResponse}, with defaults specified
-     * in Rust, in the {@link payjoin_ffi} crate.
+     * in Rust, in the {@link payjoin} crate.
      */
     create: (partial: Partial<RequestResponse> & Required<Omit<RequestResponse, never>>) => RequestResponse;
     /**
      * Create a frozen instance of {@link RequestResponse}, with defaults specified
-     * in Rust, in the {@link payjoin_ffi} crate.
+     * in Rust, in the {@link payjoin} crate.
      */
     new: (partial: Partial<RequestResponse> & Required<Omit<RequestResponse, never>>) => RequestResponse;
     /**
-     * Defaults specified in the {@link payjoin_ffi} crate.
+     * Defaults specified in the {@link payjoin} crate.
      */
     defaults: () => Partial<RequestResponse>;
 }>;
@@ -125,291 +250,1579 @@ export type RequestV1Context = {
 export declare const RequestV1Context: Readonly<{
     /**
      * Create a frozen instance of {@link RequestV1Context}, with defaults specified
-     * in Rust, in the {@link payjoin_ffi} crate.
+     * in Rust, in the {@link payjoin} crate.
      */
     create: (partial: Partial<RequestV1Context> & Required<Omit<RequestV1Context, never>>) => RequestV1Context;
     /**
      * Create a frozen instance of {@link RequestV1Context}, with defaults specified
-     * in Rust, in the {@link payjoin_ffi} crate.
+     * in Rust, in the {@link payjoin} crate.
      */
     new: (partial: Partial<RequestV1Context> & Required<Omit<RequestV1Context, never>>) => RequestV1Context;
     /**
-     * Defaults specified in the {@link payjoin_ffi} crate.
+     * Defaults specified in the {@link payjoin} crate.
      */
     defaults: () => Partial<RequestV1Context>;
 }>;
-export type Weight = {
-    weightUnits: bigint;
-};
-/**
- * Generated factory for {@link Weight} record objects.
- */
-export declare const Weight: Readonly<{
-    /**
-     * Create a frozen instance of {@link Weight}, with defaults specified
-     * in Rust, in the {@link payjoin_ffi} crate.
-     */
-    create: (partial: Partial<Weight> & Required<Omit<Weight, never>>) => Weight;
-    /**
-     * Create a frozen instance of {@link Weight}, with defaults specified
-     * in Rust, in the {@link payjoin_ffi} crate.
-     */
-    new: (partial: Partial<Weight> & Required<Omit<Weight, never>>) => Weight;
-    /**
-     * Defaults specified in the {@link payjoin_ffi} crate.
-     */
-    defaults: () => Partial<Weight>;
-}>;
-export declare enum ForeignError_Tags {
-    InternalError = "InternalError"
-}
-export declare const ForeignError: Readonly<{
-    instanceOf: (obj: any) => obj is ForeignError;
-    InternalError: {
-        new (v0: string): {
-            readonly tag: ForeignError_Tags.InternalError;
-            readonly inner: Readonly<[string]>;
+export declare enum FfiValidationError_Tags {
+    AmountOutOfRange = "AmountOutOfRange",
+    ScriptEmpty = "ScriptEmpty",
+    ScriptTooLarge = "ScriptTooLarge",
+    WitnessItemsTooMany = "WitnessItemsTooMany",
+    WitnessItemTooLarge = "WitnessItemTooLarge",
+    WitnessTooLarge = "WitnessTooLarge",
+    WeightOutOfRange = "WeightOutOfRange",
+    FeeRateOutOfRange = "FeeRateOutOfRange",
+    ExpirationOutOfRange = "ExpirationOutOfRange"
+}
+export declare const FfiValidationError: Readonly<{
+    instanceOf: (obj: any) => obj is FfiValidationError;
+    AmountOutOfRange: {
+        new (inner: {
+            amountSat: bigint;
+            maxSat: bigint;
+        }): {
+            readonly tag: FfiValidationError_Tags.AmountOutOfRange;
+            readonly inner: Readonly<{
+                amountSat: bigint;
+                maxSat: bigint;
+            }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "ForeignError";
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
             name: string;
             message: string;
             stack?: string;
             cause?: unknown;
         };
-        "new"(v0: string): {
-            readonly tag: ForeignError_Tags.InternalError;
-            readonly inner: Readonly<[string]>;
+        "new"(inner: {
+            amountSat: bigint;
+            maxSat: bigint;
+        }): {
+            readonly tag: FfiValidationError_Tags.AmountOutOfRange;
+            readonly inner: Readonly<{
+                amountSat: bigint;
+                maxSat: bigint;
+            }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "ForeignError";
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
             name: string;
             message: string;
             stack?: string;
             cause?: unknown;
         };
         instanceOf(obj: any): obj is {
-            readonly tag: ForeignError_Tags.InternalError;
-            readonly inner: Readonly<[string]>;
+            readonly tag: FfiValidationError_Tags.AmountOutOfRange;
+            readonly inner: Readonly<{
+                amountSat: bigint;
+                maxSat: bigint;
+            }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "ForeignError";
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: FfiValidationError_Tags.AmountOutOfRange;
+            readonly inner: Readonly<{
+                amountSat: bigint;
+                maxSat: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: FfiValidationError_Tags.AmountOutOfRange;
+            readonly inner: Readonly<{
+                amountSat: bigint;
+                maxSat: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            amountSat: bigint;
+            maxSat: bigint;
+        }>;
+    };
+    ScriptEmpty: {
+        new (inner: {
+            field: string;
+        }): {
+            readonly tag: FfiValidationError_Tags.ScriptEmpty;
+            readonly inner: Readonly<{
+                field: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            field: string;
+        }): {
+            readonly tag: FfiValidationError_Tags.ScriptEmpty;
+            readonly inner: Readonly<{
+                field: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: FfiValidationError_Tags.ScriptEmpty;
+            readonly inner: Readonly<{
+                field: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: FfiValidationError_Tags.ScriptEmpty;
+            readonly inner: Readonly<{
+                field: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: FfiValidationError_Tags.ScriptEmpty;
+            readonly inner: Readonly<{
+                field: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            field: string;
+        }>;
+    };
+    ScriptTooLarge: {
+        new (inner: {
+            field: string;
+            len: bigint;
+            max: bigint;
+        }): {
+            readonly tag: FfiValidationError_Tags.ScriptTooLarge;
+            readonly inner: Readonly<{
+                field: string;
+                len: bigint;
+                max: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            field: string;
+            len: bigint;
+            max: bigint;
+        }): {
+            readonly tag: FfiValidationError_Tags.ScriptTooLarge;
+            readonly inner: Readonly<{
+                field: string;
+                len: bigint;
+                max: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: FfiValidationError_Tags.ScriptTooLarge;
+            readonly inner: Readonly<{
+                field: string;
+                len: bigint;
+                max: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: FfiValidationError_Tags.ScriptTooLarge;
+            readonly inner: Readonly<{
+                field: string;
+                len: bigint;
+                max: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: FfiValidationError_Tags.ScriptTooLarge;
+            readonly inner: Readonly<{
+                field: string;
+                len: bigint;
+                max: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            field: string;
+            len: bigint;
+            max: bigint;
+        }>;
+    };
+    WitnessItemsTooMany: {
+        new (inner: {
+            count: bigint;
+            max: bigint;
+        }): {
+            readonly tag: FfiValidationError_Tags.WitnessItemsTooMany;
+            readonly inner: Readonly<{
+                count: bigint;
+                max: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            count: bigint;
+            max: bigint;
+        }): {
+            readonly tag: FfiValidationError_Tags.WitnessItemsTooMany;
+            readonly inner: Readonly<{
+                count: bigint;
+                max: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: FfiValidationError_Tags.WitnessItemsTooMany;
+            readonly inner: Readonly<{
+                count: bigint;
+                max: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: FfiValidationError_Tags.WitnessItemsTooMany;
+            readonly inner: Readonly<{
+                count: bigint;
+                max: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: FfiValidationError_Tags.WitnessItemsTooMany;
+            readonly inner: Readonly<{
+                count: bigint;
+                max: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            count: bigint;
+            max: bigint;
+        }>;
+    };
+    WitnessItemTooLarge: {
+        new (inner: {
+            index: bigint;
+            len: bigint;
+            max: bigint;
+        }): {
+            readonly tag: FfiValidationError_Tags.WitnessItemTooLarge;
+            readonly inner: Readonly<{
+                index: bigint;
+                len: bigint;
+                max: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            index: bigint;
+            len: bigint;
+            max: bigint;
+        }): {
+            readonly tag: FfiValidationError_Tags.WitnessItemTooLarge;
+            readonly inner: Readonly<{
+                index: bigint;
+                len: bigint;
+                max: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: FfiValidationError_Tags.WitnessItemTooLarge;
+            readonly inner: Readonly<{
+                index: bigint;
+                len: bigint;
+                max: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: FfiValidationError_Tags.WitnessItemTooLarge;
+            readonly inner: Readonly<{
+                index: bigint;
+                len: bigint;
+                max: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: FfiValidationError_Tags.WitnessItemTooLarge;
+            readonly inner: Readonly<{
+                index: bigint;
+                len: bigint;
+                max: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            index: bigint;
+            len: bigint;
+            max: bigint;
+        }>;
+    };
+    WitnessTooLarge: {
+        new (inner: {
+            len: bigint;
+            max: bigint;
+        }): {
+            readonly tag: FfiValidationError_Tags.WitnessTooLarge;
+            readonly inner: Readonly<{
+                len: bigint;
+                max: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            len: bigint;
+            max: bigint;
+        }): {
+            readonly tag: FfiValidationError_Tags.WitnessTooLarge;
+            readonly inner: Readonly<{
+                len: bigint;
+                max: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: FfiValidationError_Tags.WitnessTooLarge;
+            readonly inner: Readonly<{
+                len: bigint;
+                max: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: FfiValidationError_Tags.WitnessTooLarge;
+            readonly inner: Readonly<{
+                len: bigint;
+                max: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: FfiValidationError_Tags.WitnessTooLarge;
+            readonly inner: Readonly<{
+                len: bigint;
+                max: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            len: bigint;
+            max: bigint;
+        }>;
+    };
+    WeightOutOfRange: {
+        new (inner: {
+            weightUnits: bigint;
+            maxWu: bigint;
+        }): {
+            readonly tag: FfiValidationError_Tags.WeightOutOfRange;
+            readonly inner: Readonly<{
+                weightUnits: bigint;
+                maxWu: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            weightUnits: bigint;
+            maxWu: bigint;
+        }): {
+            readonly tag: FfiValidationError_Tags.WeightOutOfRange;
+            readonly inner: Readonly<{
+                weightUnits: bigint;
+                maxWu: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: FfiValidationError_Tags.WeightOutOfRange;
+            readonly inner: Readonly<{
+                weightUnits: bigint;
+                maxWu: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: FfiValidationError_Tags.WeightOutOfRange;
+            readonly inner: Readonly<{
+                weightUnits: bigint;
+                maxWu: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: FfiValidationError_Tags.WeightOutOfRange;
+            readonly inner: Readonly<{
+                weightUnits: bigint;
+                maxWu: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            weightUnits: bigint;
+            maxWu: bigint;
+        }>;
+    };
+    FeeRateOutOfRange: {
+        new (inner: {
+            value: bigint;
+            unit: string;
+        }): {
+            readonly tag: FfiValidationError_Tags.FeeRateOutOfRange;
+            readonly inner: Readonly<{
+                value: bigint;
+                unit: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            value: bigint;
+            unit: string;
+        }): {
+            readonly tag: FfiValidationError_Tags.FeeRateOutOfRange;
+            readonly inner: Readonly<{
+                value: bigint;
+                unit: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: FfiValidationError_Tags.FeeRateOutOfRange;
+            readonly inner: Readonly<{
+                value: bigint;
+                unit: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: FfiValidationError_Tags.FeeRateOutOfRange;
+            readonly inner: Readonly<{
+                value: bigint;
+                unit: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: FfiValidationError_Tags.FeeRateOutOfRange;
+            readonly inner: Readonly<{
+                value: bigint;
+                unit: string;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            value: bigint;
+            unit: string;
+        }>;
+    };
+    ExpirationOutOfRange: {
+        new (inner: {
+            seconds: bigint;
+            max: bigint;
+        }): {
+            readonly tag: FfiValidationError_Tags.ExpirationOutOfRange;
+            readonly inner: Readonly<{
+                seconds: bigint;
+                max: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            seconds: bigint;
+            max: bigint;
+        }): {
+            readonly tag: FfiValidationError_Tags.ExpirationOutOfRange;
+            readonly inner: Readonly<{
+                seconds: bigint;
+                max: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: FfiValidationError_Tags.ExpirationOutOfRange;
+            readonly inner: Readonly<{
+                seconds: bigint;
+                max: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: FfiValidationError_Tags.ExpirationOutOfRange;
+            readonly inner: Readonly<{
+                seconds: bigint;
+                max: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: FfiValidationError_Tags.ExpirationOutOfRange;
+            readonly inner: Readonly<{
+                seconds: bigint;
+                max: bigint;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "FfiValidationError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            seconds: bigint;
+            max: bigint;
+        }>;
+    };
+}>;
+export type FfiValidationError = InstanceType<(typeof FfiValidationError)[keyof Omit<typeof FfiValidationError, "instanceOf">]>;
+export declare enum ForeignError_Tags {
+    InternalError = "InternalError"
+}
+export declare const ForeignError: Readonly<{
+    instanceOf: (obj: any) => obj is ForeignError;
+    InternalError: {
+        new (v0: string): {
+            readonly tag: ForeignError_Tags.InternalError;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ForeignError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(v0: string): {
+            readonly tag: ForeignError_Tags.InternalError;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ForeignError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ForeignError_Tags.InternalError;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ForeignError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: ForeignError_Tags.InternalError;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ForeignError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: ForeignError_Tags.InternalError;
+            readonly inner: Readonly<[string]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ForeignError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<[string]>;
+    };
+}>;
+export type ForeignError = InstanceType<(typeof ForeignError)[keyof Omit<typeof ForeignError, "instanceOf">]>;
+export declare enum InitializedTransitionOutcome_Tags {
+    Progress = "Progress",
+    Stasis = "Stasis"
+}
+export declare const InitializedTransitionOutcome: Readonly<{
+    instanceOf: (obj: any) => obj is InitializedTransitionOutcome;
+    Progress: {
+        new (inner: {
+            inner: UncheckedOriginalPayloadInterface;
+        }): {
+            readonly tag: InitializedTransitionOutcome_Tags.Progress;
+            readonly inner: Readonly<{
+                inner: UncheckedOriginalPayloadInterface;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "InitializedTransitionOutcome";
+        };
+        "new"(inner: {
+            inner: UncheckedOriginalPayloadInterface;
+        }): {
+            readonly tag: InitializedTransitionOutcome_Tags.Progress;
+            readonly inner: Readonly<{
+                inner: UncheckedOriginalPayloadInterface;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "InitializedTransitionOutcome";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: InitializedTransitionOutcome_Tags.Progress;
+            readonly inner: Readonly<{
+                inner: UncheckedOriginalPayloadInterface;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "InitializedTransitionOutcome";
+        };
+    };
+    Stasis: {
+        new (inner: {
+            inner: InitializedInterface;
+        }): {
+            readonly tag: InitializedTransitionOutcome_Tags.Stasis;
+            readonly inner: Readonly<{
+                inner: InitializedInterface;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "InitializedTransitionOutcome";
+        };
+        "new"(inner: {
+            inner: InitializedInterface;
+        }): {
+            readonly tag: InitializedTransitionOutcome_Tags.Stasis;
+            readonly inner: Readonly<{
+                inner: InitializedInterface;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "InitializedTransitionOutcome";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: InitializedTransitionOutcome_Tags.Stasis;
+            readonly inner: Readonly<{
+                inner: InitializedInterface;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "InitializedTransitionOutcome";
+        };
+    };
+}>;
+export type InitializedTransitionOutcome = InstanceType<(typeof InitializedTransitionOutcome)[keyof Omit<typeof InitializedTransitionOutcome, "instanceOf">]>;
+export declare enum InputPairError_Tags {
+    InvalidOutPoint = "InvalidOutPoint",
+    InvalidPsbtInput = "InvalidPsbtInput",
+    FfiValidation = "FfiValidation"
+}
+/**
+ * Error constructing an [`InputPair`](crate::InputPair).
+ */
+export declare const InputPairError: Readonly<{
+    instanceOf: (obj: any) => obj is InputPairError;
+    InvalidOutPoint: {
+        new (inner: {
+            txid: string;
+            vout: number;
+        }): {
+            readonly tag: InputPairError_Tags.InvalidOutPoint;
+            readonly inner: Readonly<{
+                txid: string;
+                vout: number;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "InputPairError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(inner: {
+            txid: string;
+            vout: number;
+        }): {
+            readonly tag: InputPairError_Tags.InvalidOutPoint;
+            readonly inner: Readonly<{
+                txid: string;
+                vout: number;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "InputPairError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: InputPairError_Tags.InvalidOutPoint;
+            readonly inner: Readonly<{
+                txid: string;
+                vout: number;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "InputPairError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: InputPairError_Tags.InvalidOutPoint;
+            readonly inner: Readonly<{
+                txid: string;
+                vout: number;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "InputPairError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: InputPairError_Tags.InvalidOutPoint;
+            readonly inner: Readonly<{
+                txid: string;
+                vout: number;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "InputPairError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<{
+            txid: string;
+            vout: number;
+        }>;
+    };
+    InvalidPsbtInput: {
+        new (v0: PsbtInputErrorInterface): {
+            readonly tag: InputPairError_Tags.InvalidPsbtInput;
+            readonly inner: Readonly<[PsbtInputErrorInterface]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "InputPairError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(v0: PsbtInputErrorInterface): {
+            readonly tag: InputPairError_Tags.InvalidPsbtInput;
+            readonly inner: Readonly<[PsbtInputErrorInterface]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "InputPairError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: InputPairError_Tags.InvalidPsbtInput;
+            readonly inner: Readonly<[PsbtInputErrorInterface]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "InputPairError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: InputPairError_Tags.InvalidPsbtInput;
+            readonly inner: Readonly<[PsbtInputErrorInterface]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "InputPairError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: InputPairError_Tags.InvalidPsbtInput;
+            readonly inner: Readonly<[PsbtInputErrorInterface]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "InputPairError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<[PsbtInputErrorInterface]>;
+    };
+    FfiValidation: {
+        new (v0: FfiValidationError): {
+            readonly tag: InputPairError_Tags.FfiValidation;
+            readonly inner: Readonly<[FfiValidationError]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "InputPairError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(v0: FfiValidationError): {
+            readonly tag: InputPairError_Tags.FfiValidation;
+            readonly inner: Readonly<[FfiValidationError]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "InputPairError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: InputPairError_Tags.FfiValidation;
+            readonly inner: Readonly<[FfiValidationError]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "InputPairError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: InputPairError_Tags.FfiValidation;
+            readonly inner: Readonly<[FfiValidationError]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "InputPairError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: InputPairError_Tags.FfiValidation;
+            readonly inner: Readonly<[FfiValidationError]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "InputPairError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<[FfiValidationError]>;
+    };
+}>;
+/**
+ * Error constructing an [`InputPair`](crate::InputPair).
+ */
+export type InputPairError = InstanceType<(typeof InputPairError)[keyof Omit<typeof InputPairError, "instanceOf">]>;
+export declare enum OutputSubstitution {
+    Enabled = 0,
+    Disabled = 1
+}
+export declare enum OutputSubstitutionError_Tags {
+    Protocol = "Protocol",
+    FfiValidation = "FfiValidation"
+}
+/**
+ * Error that may occur when output substitution fails.
+ */
+export declare const OutputSubstitutionError: Readonly<{
+    instanceOf: (obj: any) => obj is OutputSubstitutionError;
+    Protocol: {
+        new (v0: OutputSubstitutionProtocolErrorInterface): {
+            readonly tag: OutputSubstitutionError_Tags.Protocol;
+            readonly inner: Readonly<[OutputSubstitutionProtocolErrorInterface]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "OutputSubstitutionError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(v0: OutputSubstitutionProtocolErrorInterface): {
+            readonly tag: OutputSubstitutionError_Tags.Protocol;
+            readonly inner: Readonly<[OutputSubstitutionProtocolErrorInterface]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "OutputSubstitutionError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: OutputSubstitutionError_Tags.Protocol;
+            readonly inner: Readonly<[OutputSubstitutionProtocolErrorInterface]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "OutputSubstitutionError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: OutputSubstitutionError_Tags.Protocol;
+            readonly inner: Readonly<[OutputSubstitutionProtocolErrorInterface]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "OutputSubstitutionError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: OutputSubstitutionError_Tags.Protocol;
+            readonly inner: Readonly<[OutputSubstitutionProtocolErrorInterface]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "OutputSubstitutionError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<[OutputSubstitutionProtocolErrorInterface]>;
+    };
+    FfiValidation: {
+        new (v0: FfiValidationError): {
+            readonly tag: OutputSubstitutionError_Tags.FfiValidation;
+            readonly inner: Readonly<[FfiValidationError]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "OutputSubstitutionError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(v0: FfiValidationError): {
+            readonly tag: OutputSubstitutionError_Tags.FfiValidation;
+            readonly inner: Readonly<[FfiValidationError]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "OutputSubstitutionError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: OutputSubstitutionError_Tags.FfiValidation;
+            readonly inner: Readonly<[FfiValidationError]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "OutputSubstitutionError";
             name: string;
             message: string;
             stack?: string;
             cause?: unknown;
         };
         hasInner(obj: any): obj is {
-            readonly tag: ForeignError_Tags.InternalError;
-            readonly inner: Readonly<[string]>;
+            readonly tag: OutputSubstitutionError_Tags.FfiValidation;
+            readonly inner: Readonly<[FfiValidationError]>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "ForeignError";
+            readonly [uniffiTypeNameSymbol]: "OutputSubstitutionError";
             name: string;
             message: string;
             stack?: string;
             cause?: unknown;
         };
         getInner(obj: {
-            readonly tag: ForeignError_Tags.InternalError;
-            readonly inner: Readonly<[string]>;
+            readonly tag: OutputSubstitutionError_Tags.FfiValidation;
+            readonly inner: Readonly<[FfiValidationError]>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "ForeignError";
+            readonly [uniffiTypeNameSymbol]: "OutputSubstitutionError";
             name: string;
             message: string;
             stack?: string;
             cause?: unknown;
-        }): Readonly<[string]>;
+        }): Readonly<[FfiValidationError]>;
     };
 }>;
-export type ForeignError = InstanceType<(typeof ForeignError)[keyof Omit<typeof ForeignError, "instanceOf">]>;
-export declare enum InitializedTransitionOutcome_Tags {
+/**
+ * Error that may occur when output substitution fails.
+ */
+export type OutputSubstitutionError = InstanceType<(typeof OutputSubstitutionError)[keyof Omit<typeof OutputSubstitutionError, "instanceOf">]>;
+export declare enum PollingForProposalTransitionOutcome_Tags {
     Progress = "Progress",
     Stasis = "Stasis"
 }
-export declare const InitializedTransitionOutcome: Readonly<{
-    instanceOf: (obj: any) => obj is InitializedTransitionOutcome;
+export declare const PollingForProposalTransitionOutcome: Readonly<{
+    instanceOf: (obj: any) => obj is PollingForProposalTransitionOutcome;
     Progress: {
         new (inner: {
-            inner: UncheckedOriginalPayloadInterface;
+            psbtBase64: string;
         }): {
-            readonly tag: InitializedTransitionOutcome_Tags.Progress;
+            readonly tag: PollingForProposalTransitionOutcome_Tags.Progress;
             readonly inner: Readonly<{
-                inner: UncheckedOriginalPayloadInterface;
+                psbtBase64: string;
             }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "InitializedTransitionOutcome";
+            readonly [uniffiTypeNameSymbol]: "PollingForProposalTransitionOutcome";
         };
         "new"(inner: {
-            inner: UncheckedOriginalPayloadInterface;
+            psbtBase64: string;
         }): {
-            readonly tag: InitializedTransitionOutcome_Tags.Progress;
+            readonly tag: PollingForProposalTransitionOutcome_Tags.Progress;
             readonly inner: Readonly<{
-                inner: UncheckedOriginalPayloadInterface;
+                psbtBase64: string;
             }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "InitializedTransitionOutcome";
+            readonly [uniffiTypeNameSymbol]: "PollingForProposalTransitionOutcome";
         };
         instanceOf(obj: any): obj is {
-            readonly tag: InitializedTransitionOutcome_Tags.Progress;
+            readonly tag: PollingForProposalTransitionOutcome_Tags.Progress;
             readonly inner: Readonly<{
-                inner: UncheckedOriginalPayloadInterface;
+                psbtBase64: string;
             }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "InitializedTransitionOutcome";
+            readonly [uniffiTypeNameSymbol]: "PollingForProposalTransitionOutcome";
         };
     };
     Stasis: {
         new (inner: {
-            inner: InitializedInterface;
+            inner: PollingForProposalInterface;
         }): {
-            readonly tag: InitializedTransitionOutcome_Tags.Stasis;
+            readonly tag: PollingForProposalTransitionOutcome_Tags.Stasis;
             readonly inner: Readonly<{
-                inner: InitializedInterface;
+                inner: PollingForProposalInterface;
             }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "InitializedTransitionOutcome";
+            readonly [uniffiTypeNameSymbol]: "PollingForProposalTransitionOutcome";
         };
         "new"(inner: {
-            inner: InitializedInterface;
+            inner: PollingForProposalInterface;
         }): {
-            readonly tag: InitializedTransitionOutcome_Tags.Stasis;
+            readonly tag: PollingForProposalTransitionOutcome_Tags.Stasis;
             readonly inner: Readonly<{
-                inner: InitializedInterface;
+                inner: PollingForProposalInterface;
             }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "InitializedTransitionOutcome";
+            readonly [uniffiTypeNameSymbol]: "PollingForProposalTransitionOutcome";
         };
         instanceOf(obj: any): obj is {
-            readonly tag: InitializedTransitionOutcome_Tags.Stasis;
+            readonly tag: PollingForProposalTransitionOutcome_Tags.Stasis;
             readonly inner: Readonly<{
-                inner: InitializedInterface;
+                inner: PollingForProposalInterface;
             }>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "InitializedTransitionOutcome";
+            readonly [uniffiTypeNameSymbol]: "PollingForProposalTransitionOutcome";
         };
     };
 }>;
-export type InitializedTransitionOutcome = InstanceType<(typeof InitializedTransitionOutcome)[keyof Omit<typeof InitializedTransitionOutcome, "instanceOf">]>;
-export declare enum OutputSubstitution {
-    Enabled = 0,
-    Disabled = 1
-}
-export declare enum PollingForProposalTransitionOutcome_Tags {
-    Progress = "Progress",
-    Stasis = "Stasis"
+export type PollingForProposalTransitionOutcome = InstanceType<(typeof PollingForProposalTransitionOutcome)[keyof Omit<typeof PollingForProposalTransitionOutcome, "instanceOf">]>;
+export declare enum PsbtParseError_Tags {
+    InvalidPsbt = "InvalidPsbt"
 }
-export declare const PollingForProposalTransitionOutcome: Readonly<{
-    instanceOf: (obj: any) => obj is PollingForProposalTransitionOutcome;
-    Progress: {
-        new (inner: {
-            inner: PsbtInterface;
-        }): {
-            readonly tag: PollingForProposalTransitionOutcome_Tags.Progress;
-            readonly inner: Readonly<{
-                inner: PsbtInterface;
-            }>;
+/**
+ * FFI-visible PSBT parsing error surfaced at the sender boundary.
+ */
+export declare const PsbtParseError: Readonly<{
+    instanceOf: (obj: any) => obj is PsbtParseError;
+    InvalidPsbt: {
+        new (v0: string): {
+            readonly tag: PsbtParseError_Tags.InvalidPsbt;
+            readonly inner: Readonly<[string]>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "PollingForProposalTransitionOutcome";
+            readonly [uniffiTypeNameSymbol]: "PsbtParseError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
         };
-        "new"(inner: {
-            inner: PsbtInterface;
-        }): {
-            readonly tag: PollingForProposalTransitionOutcome_Tags.Progress;
-            readonly inner: Readonly<{
-                inner: PsbtInterface;
-            }>;
+        "new"(v0: string): {
+            readonly tag: PsbtParseError_Tags.InvalidPsbt;
+            readonly inner: Readonly<[string]>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "PollingForProposalTransitionOutcome";
+            readonly [uniffiTypeNameSymbol]: "PsbtParseError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
         };
         instanceOf(obj: any): obj is {
-            readonly tag: PollingForProposalTransitionOutcome_Tags.Progress;
-            readonly inner: Readonly<{
-                inner: PsbtInterface;
-            }>;
-            /**
-             * @private
-             * This field is private and should not be used, use `tag` instead.
-             */
-            readonly [uniffiTypeNameSymbol]: "PollingForProposalTransitionOutcome";
-        };
-    };
-    Stasis: {
-        new (inner: {
-            inner: PollingForProposalInterface;
-        }): {
-            readonly tag: PollingForProposalTransitionOutcome_Tags.Stasis;
-            readonly inner: Readonly<{
-                inner: PollingForProposalInterface;
-            }>;
+            readonly tag: PsbtParseError_Tags.InvalidPsbt;
+            readonly inner: Readonly<[string]>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "PollingForProposalTransitionOutcome";
+            readonly [uniffiTypeNameSymbol]: "PsbtParseError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
         };
-        "new"(inner: {
-            inner: PollingForProposalInterface;
-        }): {
-            readonly tag: PollingForProposalTransitionOutcome_Tags.Stasis;
-            readonly inner: Readonly<{
-                inner: PollingForProposalInterface;
-            }>;
+        hasInner(obj: any): obj is {
+            readonly tag: PsbtParseError_Tags.InvalidPsbt;
+            readonly inner: Readonly<[string]>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "PollingForProposalTransitionOutcome";
+            readonly [uniffiTypeNameSymbol]: "PsbtParseError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
         };
-        instanceOf(obj: any): obj is {
-            readonly tag: PollingForProposalTransitionOutcome_Tags.Stasis;
-            readonly inner: Readonly<{
-                inner: PollingForProposalInterface;
-            }>;
+        getInner(obj: {
+            readonly tag: PsbtParseError_Tags.InvalidPsbt;
+            readonly inner: Readonly<[string]>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "PollingForProposalTransitionOutcome";
-        };
+            readonly [uniffiTypeNameSymbol]: "PsbtParseError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<[string]>;
     };
 }>;
-export type PollingForProposalTransitionOutcome = InstanceType<(typeof PollingForProposalTransitionOutcome)[keyof Omit<typeof PollingForProposalTransitionOutcome, "instanceOf">]>;
+/**
+ * FFI-visible PSBT parsing error surfaced at the sender boundary.
+ */
+export type PsbtParseError = InstanceType<(typeof PsbtParseError)[keyof Omit<typeof PsbtParseError, "instanceOf">]>;
 export declare enum ReceiveSession_Tags {
     Initialized = "Initialized",
     UncheckedOriginalPayload = "UncheckedOriginalPayload",
@@ -868,74 +2281,222 @@ export declare const ReceiveSession: Readonly<{
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "ReceiveSession";
-        };
-        "new"(inner: {
-            inner: MonitorInterface;
-        }): {
-            readonly tag: ReceiveSession_Tags.Monitor;
-            readonly inner: Readonly<{
-                inner: MonitorInterface;
-            }>;
+            readonly [uniffiTypeNameSymbol]: "ReceiveSession";
+        };
+        "new"(inner: {
+            inner: MonitorInterface;
+        }): {
+            readonly tag: ReceiveSession_Tags.Monitor;
+            readonly inner: Readonly<{
+                inner: MonitorInterface;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ReceiveSession";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ReceiveSession_Tags.Monitor;
+            readonly inner: Readonly<{
+                inner: MonitorInterface;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ReceiveSession";
+        };
+    };
+    Closed: {
+        new (inner: {
+            inner: ReceiverSessionOutcomeInterface;
+        }): {
+            readonly tag: ReceiveSession_Tags.Closed;
+            readonly inner: Readonly<{
+                inner: ReceiverSessionOutcomeInterface;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ReceiveSession";
+        };
+        "new"(inner: {
+            inner: ReceiverSessionOutcomeInterface;
+        }): {
+            readonly tag: ReceiveSession_Tags.Closed;
+            readonly inner: Readonly<{
+                inner: ReceiverSessionOutcomeInterface;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ReceiveSession";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ReceiveSession_Tags.Closed;
+            readonly inner: Readonly<{
+                inner: ReceiverSessionOutcomeInterface;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ReceiveSession";
+        };
+    };
+}>;
+export type ReceiveSession = InstanceType<(typeof ReceiveSession)[keyof Omit<typeof ReceiveSession, "instanceOf">]>;
+export declare enum ReceiverBuilderError_Tags {
+    InvalidAddress = "InvalidAddress",
+    IntoUrl = "IntoUrl"
+}
+/**
+ * Error that may occur when building a receiver session.
+ */
+export declare const ReceiverBuilderError: Readonly<{
+    instanceOf: (obj: any) => obj is ReceiverBuilderError;
+    InvalidAddress: {
+        new (v0: AddressParseErrorInterface): {
+            readonly tag: ReceiverBuilderError_Tags.InvalidAddress;
+            readonly inner: Readonly<[AddressParseErrorInterface]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ReceiverBuilderError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(v0: AddressParseErrorInterface): {
+            readonly tag: ReceiverBuilderError_Tags.InvalidAddress;
+            readonly inner: Readonly<[AddressParseErrorInterface]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ReceiverBuilderError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: ReceiverBuilderError_Tags.InvalidAddress;
+            readonly inner: Readonly<[AddressParseErrorInterface]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ReceiverBuilderError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: ReceiverBuilderError_Tags.InvalidAddress;
+            readonly inner: Readonly<[AddressParseErrorInterface]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ReceiverBuilderError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: ReceiverBuilderError_Tags.InvalidAddress;
+            readonly inner: Readonly<[AddressParseErrorInterface]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "ReceiverBuilderError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<[AddressParseErrorInterface]>;
+    };
+    IntoUrl: {
+        new (v0: IntoUrlErrorInterface): {
+            readonly tag: ReceiverBuilderError_Tags.IntoUrl;
+            readonly inner: Readonly<[IntoUrlErrorInterface]>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "ReceiveSession";
+            readonly [uniffiTypeNameSymbol]: "ReceiverBuilderError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
         };
-        instanceOf(obj: any): obj is {
-            readonly tag: ReceiveSession_Tags.Monitor;
-            readonly inner: Readonly<{
-                inner: MonitorInterface;
-            }>;
+        "new"(v0: IntoUrlErrorInterface): {
+            readonly tag: ReceiverBuilderError_Tags.IntoUrl;
+            readonly inner: Readonly<[IntoUrlErrorInterface]>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "ReceiveSession";
+            readonly [uniffiTypeNameSymbol]: "ReceiverBuilderError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
         };
-    };
-    Closed: {
-        new (inner: {
-            inner: ReceiverSessionOutcomeInterface;
-        }): {
-            readonly tag: ReceiveSession_Tags.Closed;
-            readonly inner: Readonly<{
-                inner: ReceiverSessionOutcomeInterface;
-            }>;
+        instanceOf(obj: any): obj is {
+            readonly tag: ReceiverBuilderError_Tags.IntoUrl;
+            readonly inner: Readonly<[IntoUrlErrorInterface]>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "ReceiveSession";
+            readonly [uniffiTypeNameSymbol]: "ReceiverBuilderError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
         };
-        "new"(inner: {
-            inner: ReceiverSessionOutcomeInterface;
-        }): {
-            readonly tag: ReceiveSession_Tags.Closed;
-            readonly inner: Readonly<{
-                inner: ReceiverSessionOutcomeInterface;
-            }>;
+        hasInner(obj: any): obj is {
+            readonly tag: ReceiverBuilderError_Tags.IntoUrl;
+            readonly inner: Readonly<[IntoUrlErrorInterface]>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "ReceiveSession";
+            readonly [uniffiTypeNameSymbol]: "ReceiverBuilderError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
         };
-        instanceOf(obj: any): obj is {
-            readonly tag: ReceiveSession_Tags.Closed;
-            readonly inner: Readonly<{
-                inner: ReceiverSessionOutcomeInterface;
-            }>;
+        getInner(obj: {
+            readonly tag: ReceiverBuilderError_Tags.IntoUrl;
+            readonly inner: Readonly<[IntoUrlErrorInterface]>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "ReceiveSession";
-        };
+            readonly [uniffiTypeNameSymbol]: "ReceiverBuilderError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<[IntoUrlErrorInterface]>;
     };
 }>;
-export type ReceiveSession = InstanceType<(typeof ReceiveSession)[keyof Omit<typeof ReceiveSession, "instanceOf">]>;
+/**
+ * Error that may occur when building a receiver session.
+ */
+export type ReceiverBuilderError = InstanceType<(typeof ReceiverBuilderError)[keyof Omit<typeof ReceiverBuilderError, "instanceOf">]>;
 export declare enum ReceiverError_Tags {
     Protocol = "Protocol",
     Implementation = "Implementation",
@@ -1634,89 +3195,305 @@ export declare const SendSession: Readonly<{
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "SendSession";
+            readonly [uniffiTypeNameSymbol]: "SendSession";
+        };
+    };
+    PollingForProposal: {
+        new (inner: {
+            inner: PollingForProposalInterface;
+        }): {
+            readonly tag: SendSession_Tags.PollingForProposal;
+            readonly inner: Readonly<{
+                inner: PollingForProposalInterface;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SendSession";
+        };
+        "new"(inner: {
+            inner: PollingForProposalInterface;
+        }): {
+            readonly tag: SendSession_Tags.PollingForProposal;
+            readonly inner: Readonly<{
+                inner: PollingForProposalInterface;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SendSession";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: SendSession_Tags.PollingForProposal;
+            readonly inner: Readonly<{
+                inner: PollingForProposalInterface;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SendSession";
+        };
+    };
+    Closed: {
+        new (inner: {
+            inner: SenderSessionOutcomeInterface;
+        }): {
+            readonly tag: SendSession_Tags.Closed;
+            readonly inner: Readonly<{
+                inner: SenderSessionOutcomeInterface;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SendSession";
+        };
+        "new"(inner: {
+            inner: SenderSessionOutcomeInterface;
+        }): {
+            readonly tag: SendSession_Tags.Closed;
+            readonly inner: Readonly<{
+                inner: SenderSessionOutcomeInterface;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SendSession";
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: SendSession_Tags.Closed;
+            readonly inner: Readonly<{
+                inner: SenderSessionOutcomeInterface;
+            }>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SendSession";
+        };
+    };
+}>;
+export type SendSession = InstanceType<(typeof SendSession)[keyof Omit<typeof SendSession, "instanceOf">]>;
+export declare enum SenderInputError_Tags {
+    Psbt = "Psbt",
+    Build = "Build",
+    FfiValidation = "FfiValidation"
+}
+/**
+ * Raised when inputs provided to the sender are malformed or sender build fails.
+ */
+export declare const SenderInputError: Readonly<{
+    instanceOf: (obj: any) => obj is SenderInputError;
+    Psbt: {
+        new (v0: PsbtParseError): {
+            readonly tag: SenderInputError_Tags.Psbt;
+            readonly inner: Readonly<[PsbtParseError]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SenderInputError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(v0: PsbtParseError): {
+            readonly tag: SenderInputError_Tags.Psbt;
+            readonly inner: Readonly<[PsbtParseError]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SenderInputError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: SenderInputError_Tags.Psbt;
+            readonly inner: Readonly<[PsbtParseError]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SenderInputError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: SenderInputError_Tags.Psbt;
+            readonly inner: Readonly<[PsbtParseError]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SenderInputError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        getInner(obj: {
+            readonly tag: SenderInputError_Tags.Psbt;
+            readonly inner: Readonly<[PsbtParseError]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SenderInputError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<[PsbtParseError]>;
+    };
+    Build: {
+        new (v0: BuildSenderErrorInterface): {
+            readonly tag: SenderInputError_Tags.Build;
+            readonly inner: Readonly<[BuildSenderErrorInterface]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SenderInputError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        "new"(v0: BuildSenderErrorInterface): {
+            readonly tag: SenderInputError_Tags.Build;
+            readonly inner: Readonly<[BuildSenderErrorInterface]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SenderInputError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        instanceOf(obj: any): obj is {
+            readonly tag: SenderInputError_Tags.Build;
+            readonly inner: Readonly<[BuildSenderErrorInterface]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SenderInputError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        hasInner(obj: any): obj is {
+            readonly tag: SenderInputError_Tags.Build;
+            readonly inner: Readonly<[BuildSenderErrorInterface]>;
+            /**
+             * @private
+             * This field is private and should not be used, use `tag` instead.
+             */
+            readonly [uniffiTypeNameSymbol]: "SenderInputError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
         };
-    };
-    PollingForProposal: {
-        new (inner: {
-            inner: PollingForProposalInterface;
-        }): {
-            readonly tag: SendSession_Tags.PollingForProposal;
-            readonly inner: Readonly<{
-                inner: PollingForProposalInterface;
-            }>;
+        getInner(obj: {
+            readonly tag: SenderInputError_Tags.Build;
+            readonly inner: Readonly<[BuildSenderErrorInterface]>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "SendSession";
-        };
-        "new"(inner: {
-            inner: PollingForProposalInterface;
-        }): {
-            readonly tag: SendSession_Tags.PollingForProposal;
-            readonly inner: Readonly<{
-                inner: PollingForProposalInterface;
-            }>;
+            readonly [uniffiTypeNameSymbol]: "SenderInputError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<[BuildSenderErrorInterface]>;
+    };
+    FfiValidation: {
+        new (v0: FfiValidationError): {
+            readonly tag: SenderInputError_Tags.FfiValidation;
+            readonly inner: Readonly<[FfiValidationError]>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "SendSession";
+            readonly [uniffiTypeNameSymbol]: "SenderInputError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
         };
-        instanceOf(obj: any): obj is {
-            readonly tag: SendSession_Tags.PollingForProposal;
-            readonly inner: Readonly<{
-                inner: PollingForProposalInterface;
-            }>;
+        "new"(v0: FfiValidationError): {
+            readonly tag: SenderInputError_Tags.FfiValidation;
+            readonly inner: Readonly<[FfiValidationError]>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "SendSession";
+            readonly [uniffiTypeNameSymbol]: "SenderInputError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
         };
-    };
-    Closed: {
-        new (inner: {
-            inner: SenderSessionOutcomeInterface;
-        }): {
-            readonly tag: SendSession_Tags.Closed;
-            readonly inner: Readonly<{
-                inner: SenderSessionOutcomeInterface;
-            }>;
+        instanceOf(obj: any): obj is {
+            readonly tag: SenderInputError_Tags.FfiValidation;
+            readonly inner: Readonly<[FfiValidationError]>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "SendSession";
+            readonly [uniffiTypeNameSymbol]: "SenderInputError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
         };
-        "new"(inner: {
-            inner: SenderSessionOutcomeInterface;
-        }): {
-            readonly tag: SendSession_Tags.Closed;
-            readonly inner: Readonly<{
-                inner: SenderSessionOutcomeInterface;
-            }>;
+        hasInner(obj: any): obj is {
+            readonly tag: SenderInputError_Tags.FfiValidation;
+            readonly inner: Readonly<[FfiValidationError]>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "SendSession";
+            readonly [uniffiTypeNameSymbol]: "SenderInputError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
         };
-        instanceOf(obj: any): obj is {
-            readonly tag: SendSession_Tags.Closed;
-            readonly inner: Readonly<{
-                inner: SenderSessionOutcomeInterface;
-            }>;
+        getInner(obj: {
+            readonly tag: SenderInputError_Tags.FfiValidation;
+            readonly inner: Readonly<[FfiValidationError]>;
             /**
              * @private
              * This field is private and should not be used, use `tag` instead.
              */
-            readonly [uniffiTypeNameSymbol]: "SendSession";
-        };
+            readonly [uniffiTypeNameSymbol]: "SenderInputError";
+            name: string;
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        }): Readonly<[FfiValidationError]>;
     };
 }>;
-export type SendSession = InstanceType<(typeof SendSession)[keyof Omit<typeof SendSession, "instanceOf">]>;
+/**
+ * Raised when inputs provided to the sender are malformed or sender build fails.
+ */
+export type SenderInputError = InstanceType<(typeof SenderInputError)[keyof Omit<typeof SenderInputError, "instanceOf">]>;
 export declare enum SenderPersistedError_Tags {
     EncapsulationError = "EncapsulationError",
     ResponseError = "ResponseError",
@@ -2052,8 +3829,42 @@ export declare const SenderPersistedError: Readonly<{
  * Error that may occur during state machine transitions
  */
 export type SenderPersistedError = InstanceType<(typeof SenderPersistedError)[keyof Omit<typeof SenderPersistedError, "instanceOf">]>;
+/**
+ * Error parsing a Bitcoin address.
+ */
+export interface AddressParseErrorInterface {
+}
+/**
+ * Error parsing a Bitcoin address.
+ */
+export declare class AddressParseError extends UniffiAbstractObject implements AddressParseErrorInterface {
+    readonly [uniffiTypeNameSymbol] = "AddressParseError";
+    readonly [destructorGuardSymbol]: UniffiRustArcPtr;
+    readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
+    private constructor();
+    /**
+     * Calls into the `Debug` string representation of `AddressParseErrorInterface` (the native Rust peer).
+     *
+     * Generated by deriving the `Debug` trait in Rust.
+     */
+    toDebugString(): string;
+    /**
+     * Calls into the `AddressParseErrorInterface::to_string()` method of the native Rust peer.
+     *
+     * Generated by deriving the `Display` trait in Rust.
+     */
+    toString(): string;
+    /**
+     * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+     */
+    uniffiDestroy(): void;
+    static instanceOf(obj: any): obj is AddressParseError;
+}
 export interface AssumeInteractiveTransitionInterface {
     save(persister: JsonReceiverSessionPersister): MaybeInputsOwnedInterface;
+    saveAsync(persister: JsonReceiverSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<MaybeInputsOwnedInterface>;
 }
 export declare class AssumeInteractiveTransition extends UniffiAbstractObject implements AssumeInteractiveTransitionInterface {
     readonly [uniffiTypeNameSymbol] = "AssumeInteractiveTransition";
@@ -2061,6 +3872,9 @@ export declare class AssumeInteractiveTransition extends UniffiAbstractObject im
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
     save(persister: JsonReceiverSessionPersister): MaybeInputsOwnedInterface;
+    saveAsync(persister: JsonReceiverSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<MaybeInputsOwnedInterface>;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -2084,13 +3898,32 @@ export declare class BuildSenderError extends UniffiAbstractObject implements Bu
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
+    /**
+     * Calls into the `Debug` string representation of `BuildSenderErrorInterface` (the native Rust peer).
+     *
+     * Generated by deriving the `Debug` trait in Rust.
+     */
+    toDebugString(): string;
+    /**
+     * Calls into the `BuildSenderErrorInterface::to_string()` method of the native Rust peer.
+     *
+     * Generated by deriving the `Display` trait in Rust.
+     */
+    toString(): string;
+    /**
+     * Calls into the `==` method of `BuildSenderErrorInterface` (the native Rust peer).
+     *
+     * Returns `true` if and only if the two instance of `BuildSenderErrorInterface` are
+     * equivalent on the Rust side.
+     *
+     * Generated by deriving the `Eq` trait in Rust.
+     */
+    equals(other: BuildSenderError): boolean;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
     uniffiDestroy(): void;
     static instanceOf(obj: any): obj is BuildSenderError;
-    static hasInner(obj: any): obj is UniffiThrownObject<BuildSenderError>;
-    static getInner(err: UniffiThrownObject<BuildSenderError>): BuildSenderError;
 }
 export interface CanBroadcast {
     callback(tx: ArrayBuffer): boolean;
@@ -2107,6 +3940,47 @@ export declare class CanBroadcastImpl extends UniffiAbstractObject implements Ca
     uniffiDestroy(): void;
     static instanceOf(obj: any): obj is CanBroadcastImpl;
 }
+/**
+ * A terminal transition produced by cancelling a receiver session.
+ */
+export interface CancelTransitionInterface {
+    /**
+     * Persist the cancellation and return the fallback transaction if available.
+     *
+     * The fallback transaction is the consensus-encoded raw transaction bytes,
+     * or `None` if the session was cancelled before the sender's original
+     * proposal was received.
+     */
+    save(persister: JsonReceiverSessionPersister): ArrayBuffer | undefined;
+    saveAsync(persister: JsonReceiverSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ArrayBuffer | undefined>;
+}
+/**
+ * A terminal transition produced by cancelling a receiver session.
+ */
+export declare class CancelTransition extends UniffiAbstractObject implements CancelTransitionInterface {
+    readonly [uniffiTypeNameSymbol] = "CancelTransition";
+    readonly [destructorGuardSymbol]: UniffiRustArcPtr;
+    readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
+    private constructor();
+    /**
+     * Persist the cancellation and return the fallback transaction if available.
+     *
+     * The fallback transaction is the consensus-encoded raw transaction bytes,
+     * or `None` if the session was cancelled before the sender's original
+     * proposal was received.
+     */
+    save(persister: JsonReceiverSessionPersister): ArrayBuffer | undefined;
+    saveAsync(persister: JsonReceiverSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ArrayBuffer | undefined>;
+    /**
+     * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+     */
+    uniffiDestroy(): void;
+    static instanceOf(obj: any): obj is CancelTransition;
+}
 export interface ClientResponseInterface {
 }
 export declare class ClientResponse extends UniffiAbstractObject implements ClientResponseInterface {
@@ -2141,6 +4015,18 @@ export declare class CreateRequestError extends UniffiAbstractObject implements
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
+    /**
+     * Calls into the `Debug` string representation of `CreateRequestErrorInterface` (the native Rust peer).
+     *
+     * Generated by deriving the `Debug` trait in Rust.
+     */
+    toDebugString(): string;
+    /**
+     * Calls into the `CreateRequestErrorInterface::to_string()` method of the native Rust peer.
+     *
+     * Generated by deriving the `Display` trait in Rust.
+     */
+    toString(): string;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -2162,6 +4048,18 @@ export declare class EncapsulationError extends UniffiAbstractObject implements
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
+    /**
+     * Calls into the `Debug` string representation of `EncapsulationErrorInterface` (the native Rust peer).
+     *
+     * Generated by deriving the `Debug` trait in Rust.
+     */
+    toDebugString(): string;
+    /**
+     * Calls into the `EncapsulationErrorInterface::to_string()` method of the native Rust peer.
+     *
+     * Generated by deriving the `Display` trait in Rust.
+     */
+    toString(): string;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -2175,6 +4073,18 @@ export declare class FeeRateError extends UniffiAbstractObject implements FeeRat
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
+    /**
+     * Calls into the `Debug` string representation of `FeeRateErrorInterface` (the native Rust peer).
+     *
+     * Generated by deriving the `Debug` trait in Rust.
+     */
+    toDebugString(): string;
+    /**
+     * Calls into the `FeeRateErrorInterface::to_string()` method of the native Rust peer.
+     *
+     * Generated by deriving the `Display` trait in Rust.
+     */
+    toString(): string;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -2184,6 +4094,16 @@ export declare class FeeRateError extends UniffiAbstractObject implements FeeRat
     static getInner(err: UniffiThrownObject<FeeRateError>): FeeRateError;
 }
 export interface HasReplyableErrorInterface {
+    /**
+     * Cancel the Payjoin session immediately.
+     *
+     * Returns a [`CancelTransition`] that, once persisted, yields the fallback
+     * transaction when applicable. The fallback transaction is the sender's original
+     * transaction that should be broadcast to complete the payment without Payjoin.
+     *
+     * This is a terminal transition — the session cannot be used after cancellation.
+     */
+    cancel(): CancelTransitionInterface;
     createErrorRequest(ohttpRelay: string): RequestResponse;
     processErrorResponse(body: ArrayBuffer, ohttpContext: ClientResponseInterface): HasReplyableErrorTransitionInterface;
 }
@@ -2192,6 +4112,16 @@ export declare class HasReplyableError extends UniffiAbstractObject implements H
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
+    /**
+     * Cancel the Payjoin session immediately.
+     *
+     * Returns a [`CancelTransition`] that, once persisted, yields the fallback
+     * transaction when applicable. The fallback transaction is the sender's original
+     * transaction that should be broadcast to complete the payment without Payjoin.
+     *
+     * This is a terminal transition — the session cannot be used after cancellation.
+     */
+    cancel(): CancelTransitionInterface;
     createErrorRequest(ohttpRelay: string): RequestResponse;
     processErrorResponse(body: ArrayBuffer, ohttpContext: ClientResponseInterface): HasReplyableErrorTransitionInterface;
     /**
@@ -2202,6 +4132,9 @@ export declare class HasReplyableError extends UniffiAbstractObject implements H
 }
 export interface HasReplyableErrorTransitionInterface {
     save(persister: JsonReceiverSessionPersister): void;
+    saveAsync(persister: JsonReceiverSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
 }
 export declare class HasReplyableErrorTransition extends UniffiAbstractObject implements HasReplyableErrorTransitionInterface {
     readonly [uniffiTypeNameSymbol] = "HasReplyableErrorTransition";
@@ -2209,6 +4142,9 @@ export declare class HasReplyableErrorTransition extends UniffiAbstractObject im
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
     save(persister: JsonReceiverSessionPersister): void;
+    saveAsync(persister: JsonReceiverSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -2232,6 +4168,18 @@ export declare class ImplementationError extends UniffiAbstractObject implements
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
+    /**
+     * Calls into the `Debug` string representation of `ImplementationErrorInterface` (the native Rust peer).
+     *
+     * Generated by deriving the `Debug` trait in Rust.
+     */
+    toDebugString(): string;
+    /**
+     * Calls into the `ImplementationErrorInterface::to_string()` method of the native Rust peer.
+     *
+     * Generated by deriving the `Display` trait in Rust.
+     */
+    toString(): string;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -2240,6 +4188,9 @@ export declare class ImplementationError extends UniffiAbstractObject implements
 }
 export interface InitialReceiveTransitionInterface {
     save(persister: JsonReceiverSessionPersister): InitializedInterface;
+    saveAsync(persister: JsonReceiverSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<InitializedInterface>;
 }
 export declare class InitialReceiveTransition extends UniffiAbstractObject implements InitialReceiveTransitionInterface {
     readonly [uniffiTypeNameSymbol] = "InitialReceiveTransition";
@@ -2247,6 +4198,9 @@ export declare class InitialReceiveTransition extends UniffiAbstractObject imple
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
     save(persister: JsonReceiverSessionPersister): InitializedInterface;
+    saveAsync(persister: JsonReceiverSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<InitializedInterface>;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -2255,6 +4209,9 @@ export declare class InitialReceiveTransition extends UniffiAbstractObject imple
 }
 export interface InitialSendTransitionInterface {
     save(persister: JsonSenderSessionPersister): WithReplyKeyInterface;
+    saveAsync(persister: JsonSenderSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<WithReplyKeyInterface>;
 }
 export declare class InitialSendTransition extends UniffiAbstractObject implements InitialSendTransitionInterface {
     readonly [uniffiTypeNameSymbol] = "InitialSendTransition";
@@ -2262,6 +4219,9 @@ export declare class InitialSendTransition extends UniffiAbstractObject implemen
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
     save(persister: JsonSenderSessionPersister): WithReplyKeyInterface;
+    saveAsync(persister: JsonSenderSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<WithReplyKeyInterface>;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -2269,6 +4229,16 @@ export declare class InitialSendTransition extends UniffiAbstractObject implemen
     static instanceOf(obj: any): obj is InitialSendTransition;
 }
 export interface InitializedInterface {
+    /**
+     * Cancel the Payjoin session immediately.
+     *
+     * Returns a [`CancelTransition`] that, once persisted, yields the fallback
+     * transaction when applicable. The fallback transaction is the sender's original
+     * transaction that should be broadcast to complete the payment without Payjoin.
+     *
+     * This is a terminal transition — the session cannot be used after cancellation.
+     */
+    cancel(): CancelTransitionInterface;
     /**
      * Construct an OHTTP encapsulated GET request, polling the mailbox for the Original PSBT
      */
@@ -2287,6 +4257,16 @@ export declare class Initialized extends UniffiAbstractObject implements Initial
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
+    /**
+     * Cancel the Payjoin session immediately.
+     *
+     * Returns a [`CancelTransition`] that, once persisted, yields the fallback
+     * transaction when applicable. The fallback transaction is the sender's original
+     * transaction that should be broadcast to complete the payment without Payjoin.
+     *
+     * This is a terminal transition — the session cannot be used after cancellation.
+     */
+    cancel(): CancelTransitionInterface;
     /**
      * Construct an OHTTP encapsulated GET request, polling the mailbox for the Original PSBT
      */
@@ -2307,6 +4287,9 @@ export declare class Initialized extends UniffiAbstractObject implements Initial
 }
 export interface InitializedTransitionInterface {
     save(persister: JsonReceiverSessionPersister): InitializedTransitionOutcome;
+    saveAsync(persister: JsonReceiverSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<InitializedTransitionOutcome>;
 }
 export declare class InitializedTransition extends UniffiAbstractObject implements InitializedTransitionInterface {
     readonly [uniffiTypeNameSymbol] = "InitializedTransition";
@@ -2314,6 +4297,9 @@ export declare class InitializedTransition extends UniffiAbstractObject implemen
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
     save(persister: JsonReceiverSessionPersister): InitializedTransitionOutcome;
+    saveAsync(persister: JsonReceiverSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<InitializedTransitionOutcome>;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -2333,6 +4319,18 @@ export declare class InputContributionError extends UniffiAbstractObject impleme
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
+    /**
+     * Calls into the `Debug` string representation of `InputContributionErrorInterface` (the native Rust peer).
+     *
+     * Generated by deriving the `Debug` trait in Rust.
+     */
+    toDebugString(): string;
+    /**
+     * Calls into the `InputContributionErrorInterface::to_string()` method of the native Rust peer.
+     *
+     * Generated by deriving the `Display` trait in Rust.
+     */
+    toString(): string;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -2347,7 +4345,7 @@ export declare class InputPair extends UniffiAbstractObject implements InputPair
     readonly [uniffiTypeNameSymbol] = "InputPair";
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
-    constructor(txin: TxIn, psbtin: PsbtInput, expectedWeight: Weight | undefined);
+    constructor(txin: PlainTxIn, psbtin: PlainPsbtInput, expectedWeight: PlainWeight | undefined);
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -2361,23 +4359,33 @@ export declare class IntoUrlError extends UniffiAbstractObject implements IntoUr
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
+    /**
+     * Calls into the `Debug` string representation of `IntoUrlErrorInterface` (the native Rust peer).
+     *
+     * Generated by deriving the `Debug` trait in Rust.
+     */
+    toDebugString(): string;
+    /**
+     * Calls into the `IntoUrlErrorInterface::to_string()` method of the native Rust peer.
+     *
+     * Generated by deriving the `Display` trait in Rust.
+     */
+    toString(): string;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
     uniffiDestroy(): void;
     static instanceOf(obj: any): obj is IntoUrlError;
-    static hasInner(obj: any): obj is UniffiThrownObject<IntoUrlError>;
-    static getInner(err: UniffiThrownObject<IntoUrlError>): IntoUrlError;
 }
 export interface IsOutputKnown {
-    callback(outpoint: OutPoint): boolean;
+    callback(outpoint: PlainOutPoint): boolean;
 }
 export declare class IsOutputKnownImpl extends UniffiAbstractObject implements IsOutputKnown {
     readonly [uniffiTypeNameSymbol] = "IsOutputKnownImpl";
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
-    callback(outpoint: OutPoint): boolean;
+    callback(outpoint: PlainOutPoint): boolean;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -2424,6 +4432,43 @@ export declare class JsonReceiverSessionPersisterImpl extends UniffiAbstractObje
     uniffiDestroy(): void;
     static instanceOf(obj: any): obj is JsonReceiverSessionPersisterImpl;
 }
+/**
+ * Async session persister that should save and load events as JSON strings.
+ */
+export interface JsonReceiverSessionPersisterAsync {
+    save(event: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    load(asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Array<string>>;
+    close(asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
+}
+/**
+ * Async session persister that should save and load events as JSON strings.
+ */
+export declare class JsonReceiverSessionPersisterAsyncImpl extends UniffiAbstractObject implements JsonReceiverSessionPersisterAsync {
+    readonly [uniffiTypeNameSymbol] = "JsonReceiverSessionPersisterAsyncImpl";
+    readonly [destructorGuardSymbol]: UniffiRustArcPtr;
+    readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
+    private constructor();
+    save(event: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    load(asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Array<string>>;
+    close(asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    /**
+     * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+     */
+    uniffiDestroy(): void;
+    static instanceOf(obj: any): obj is JsonReceiverSessionPersisterAsyncImpl;
+}
 /**
  * The standard format for errors that can be replied as JSON.
  *
@@ -2453,6 +4498,27 @@ export declare class JsonReply extends UniffiAbstractObject implements JsonReply
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
+    /**
+     * Calls into the `Debug` string representation of `JsonReplyInterface` (the native Rust peer).
+     *
+     * Generated by deriving the `Debug` trait in Rust.
+     */
+    toDebugString(): string;
+    /**
+     * Calls into the `Debug` string representation of `JsonReplyInterface` (the native Rust peer).
+     *
+     * Generated by deriving the `Debug` trait in Rust, without deriving `Display`.
+     */
+    toString(): string;
+    /**
+     * Calls into the `==` method of `JsonReplyInterface` (the native Rust peer).
+     *
+     * Returns `true` if and only if the two instance of `JsonReplyInterface` are
+     * equivalent on the Rust side.
+     *
+     * Generated by deriving the `Eq` trait in Rust.
+     */
+    equals(other: JsonReply): boolean;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -2484,7 +4550,54 @@ export declare class JsonSenderSessionPersisterImpl extends UniffiAbstractObject
     uniffiDestroy(): void;
     static instanceOf(obj: any): obj is JsonSenderSessionPersisterImpl;
 }
+/**
+ * Async session persister that should save and load events as JSON strings.
+ */
+export interface JsonSenderSessionPersisterAsync {
+    save(event: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    load(asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Array<string>>;
+    close(asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
+}
+/**
+ * Async session persister that should save and load events as JSON strings.
+ */
+export declare class JsonSenderSessionPersisterAsyncImpl extends UniffiAbstractObject implements JsonSenderSessionPersisterAsync {
+    readonly [uniffiTypeNameSymbol] = "JsonSenderSessionPersisterAsyncImpl";
+    readonly [destructorGuardSymbol]: UniffiRustArcPtr;
+    readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
+    private constructor();
+    save(event: string, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    load(asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<Array<string>>;
+    close(asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
+    /**
+     * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+     */
+    uniffiDestroy(): void;
+    static instanceOf(obj: any): obj is JsonSenderSessionPersisterAsyncImpl;
+}
 export interface MaybeInputsOwnedInterface {
+    /**
+     * Cancel the Payjoin session immediately.
+     *
+     * Returns a [`CancelTransition`] that, once persisted, yields the fallback
+     * transaction when applicable. The fallback transaction is the sender's original
+     * transaction that should be broadcast to complete the payment without Payjoin.
+     *
+     * This is a terminal transition — the session cannot be used after cancellation.
+     */
+    cancel(): CancelTransitionInterface;
     checkInputsNotOwned(isOwned: IsScriptOwned): MaybeInputsOwnedTransitionInterface;
     /**
      * The Sender’s Original PSBT
@@ -2496,6 +4609,16 @@ export declare class MaybeInputsOwned extends UniffiAbstractObject implements Ma
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
+    /**
+     * Cancel the Payjoin session immediately.
+     *
+     * Returns a [`CancelTransition`] that, once persisted, yields the fallback
+     * transaction when applicable. The fallback transaction is the sender's original
+     * transaction that should be broadcast to complete the payment without Payjoin.
+     *
+     * This is a terminal transition — the session cannot be used after cancellation.
+     */
+    cancel(): CancelTransitionInterface;
     checkInputsNotOwned(isOwned: IsScriptOwned): MaybeInputsOwnedTransitionInterface;
     /**
      * The Sender’s Original PSBT
@@ -2509,6 +4632,9 @@ export declare class MaybeInputsOwned extends UniffiAbstractObject implements Ma
 }
 export interface MaybeInputsOwnedTransitionInterface {
     save(persister: JsonReceiverSessionPersister): MaybeInputsSeenInterface;
+    saveAsync(persister: JsonReceiverSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<MaybeInputsSeenInterface>;
 }
 export declare class MaybeInputsOwnedTransition extends UniffiAbstractObject implements MaybeInputsOwnedTransitionInterface {
     readonly [uniffiTypeNameSymbol] = "MaybeInputsOwnedTransition";
@@ -2516,6 +4642,9 @@ export declare class MaybeInputsOwnedTransition extends UniffiAbstractObject imp
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
     save(persister: JsonReceiverSessionPersister): MaybeInputsSeenInterface;
+    saveAsync(persister: JsonReceiverSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<MaybeInputsSeenInterface>;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -2523,6 +4652,16 @@ export declare class MaybeInputsOwnedTransition extends UniffiAbstractObject imp
     static instanceOf(obj: any): obj is MaybeInputsOwnedTransition;
 }
 export interface MaybeInputsSeenInterface {
+    /**
+     * Cancel the Payjoin session immediately.
+     *
+     * Returns a [`CancelTransition`] that, once persisted, yields the fallback
+     * transaction when applicable. The fallback transaction is the sender's original
+     * transaction that should be broadcast to complete the payment without Payjoin.
+     *
+     * This is a terminal transition — the session cannot be used after cancellation.
+     */
+    cancel(): CancelTransitionInterface;
     checkNoInputsSeenBefore(isKnown: IsOutputKnown): MaybeInputsSeenTransitionInterface;
 }
 export declare class MaybeInputsSeen extends UniffiAbstractObject implements MaybeInputsSeenInterface {
@@ -2530,6 +4669,16 @@ export declare class MaybeInputsSeen extends UniffiAbstractObject implements May
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
+    /**
+     * Cancel the Payjoin session immediately.
+     *
+     * Returns a [`CancelTransition`] that, once persisted, yields the fallback
+     * transaction when applicable. The fallback transaction is the sender's original
+     * transaction that should be broadcast to complete the payment without Payjoin.
+     *
+     * This is a terminal transition — the session cannot be used after cancellation.
+     */
+    cancel(): CancelTransitionInterface;
     checkNoInputsSeenBefore(isKnown: IsOutputKnown): MaybeInputsSeenTransitionInterface;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
@@ -2539,6 +4688,9 @@ export declare class MaybeInputsSeen extends UniffiAbstractObject implements May
 }
 export interface MaybeInputsSeenTransitionInterface {
     save(persister: JsonReceiverSessionPersister): OutputsUnknownInterface;
+    saveAsync(persister: JsonReceiverSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<OutputsUnknownInterface>;
 }
 export declare class MaybeInputsSeenTransition extends UniffiAbstractObject implements MaybeInputsSeenTransitionInterface {
     readonly [uniffiTypeNameSymbol] = "MaybeInputsSeenTransition";
@@ -2546,6 +4698,9 @@ export declare class MaybeInputsSeenTransition extends UniffiAbstractObject impl
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
     save(persister: JsonReceiverSessionPersister): OutputsUnknownInterface;
+    saveAsync(persister: JsonReceiverSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<OutputsUnknownInterface>;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -2553,14 +4708,34 @@ export declare class MaybeInputsSeenTransition extends UniffiAbstractObject impl
     static instanceOf(obj: any): obj is MaybeInputsSeenTransition;
 }
 export interface MonitorInterface {
-    monitor(transactionExists: TransactionExists, outpointSpent: OutpointSpent): MonitorTransitionInterface;
+    /**
+     * Cancel the Payjoin session immediately.
+     *
+     * Returns a [`CancelTransition`] that, once persisted, yields the fallback
+     * transaction when applicable. The fallback transaction is the sender's original
+     * transaction that should be broadcast to complete the payment without Payjoin.
+     *
+     * This is a terminal transition — the session cannot be used after cancellation.
+     */
+    cancel(): CancelTransitionInterface;
+    monitor(transactionExists: TransactionExists): MonitorTransitionInterface;
 }
 export declare class Monitor extends UniffiAbstractObject implements MonitorInterface {
     readonly [uniffiTypeNameSymbol] = "Monitor";
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
-    monitor(transactionExists: TransactionExists, outpointSpent: OutpointSpent): MonitorTransitionInterface;
+    /**
+     * Cancel the Payjoin session immediately.
+     *
+     * Returns a [`CancelTransition`] that, once persisted, yields the fallback
+     * transaction when applicable. The fallback transaction is the sender's original
+     * transaction that should be broadcast to complete the payment without Payjoin.
+     *
+     * This is a terminal transition — the session cannot be used after cancellation.
+     */
+    cancel(): CancelTransitionInterface;
+    monitor(transactionExists: TransactionExists): MonitorTransitionInterface;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -2569,6 +4744,9 @@ export declare class Monitor extends UniffiAbstractObject implements MonitorInte
 }
 export interface MonitorTransitionInterface {
     save(persister: JsonReceiverSessionPersister): void;
+    saveAsync(persister: JsonReceiverSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
 }
 export declare class MonitorTransition extends UniffiAbstractObject implements MonitorTransitionInterface {
     readonly [uniffiTypeNameSymbol] = "MonitorTransition";
@@ -2576,6 +4754,9 @@ export declare class MonitorTransition extends UniffiAbstractObject implements M
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
     save(persister: JsonReceiverSessionPersister): void;
+    saveAsync(persister: JsonReceiverSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<void>;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -2589,6 +4770,18 @@ export declare class OhttpError extends UniffiAbstractObject implements OhttpErr
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
+    /**
+     * Calls into the `Debug` string representation of `OhttpErrorInterface` (the native Rust peer).
+     *
+     * Generated by deriving the `Debug` trait in Rust.
+     */
+    toDebugString(): string;
+    /**
+     * Calls into the `OhttpErrorInterface::to_string()` method of the native Rust peer.
+     *
+     * Generated by deriving the `Display` trait in Rust.
+     */
+    toString(): string;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -2614,41 +4807,36 @@ export declare class OhttpKeys extends UniffiAbstractObject implements OhttpKeys
     uniffiDestroy(): void;
     static instanceOf(obj: any): obj is OhttpKeys;
 }
-export interface OutpointSpent {
-    callback(outpoint: OutPoint): boolean;
-}
-export declare class OutpointSpentImpl extends UniffiAbstractObject implements OutpointSpent {
-    readonly [uniffiTypeNameSymbol] = "OutpointSpentImpl";
-    readonly [destructorGuardSymbol]: UniffiRustArcPtr;
-    readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
-    private constructor();
-    callback(outpoint: OutPoint): boolean;
-    /**
-     * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
-     */
-    uniffiDestroy(): void;
-    static instanceOf(obj: any): obj is OutpointSpentImpl;
-}
 /**
- * Error that may occur when output substitution fails.
+ * Protocol error raised during output substitution.
  */
-export interface OutputSubstitutionErrorInterface {
+export interface OutputSubstitutionProtocolErrorInterface {
 }
 /**
- * Error that may occur when output substitution fails.
+ * Protocol error raised during output substitution.
  */
-export declare class OutputSubstitutionError extends UniffiAbstractObject implements OutputSubstitutionErrorInterface {
-    readonly [uniffiTypeNameSymbol] = "OutputSubstitutionError";
+export declare class OutputSubstitutionProtocolError extends UniffiAbstractObject implements OutputSubstitutionProtocolErrorInterface {
+    readonly [uniffiTypeNameSymbol] = "OutputSubstitutionProtocolError";
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
+    /**
+     * Calls into the `Debug` string representation of `OutputSubstitutionProtocolErrorInterface` (the native Rust peer).
+     *
+     * Generated by deriving the `Debug` trait in Rust.
+     */
+    toDebugString(): string;
+    /**
+     * Calls into the `OutputSubstitutionProtocolErrorInterface::to_string()` method of the native Rust peer.
+     *
+     * Generated by deriving the `Display` trait in Rust.
+     */
+    toString(): string;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
     uniffiDestroy(): void;
-    static instanceOf(obj: any): obj is OutputSubstitutionError;
-    static hasInner(obj: any): obj is UniffiThrownObject<OutputSubstitutionError>;
-    static getInner(err: UniffiThrownObject<OutputSubstitutionError>): OutputSubstitutionError;
+    static instanceOf(obj: any): obj is OutputSubstitutionProtocolError;
 }
 /**
  * The receiver has not yet identified which outputs belong to the receiver.
@@ -2657,6 +4845,16 @@ export declare class OutputSubstitutionError extends UniffiAbstractObject implem
  * Identify those outputs with `identify_receiver_outputs()` to proceed
  */
 export interface OutputsUnknownInterface {
+    /**
+     * Cancel the Payjoin session immediately.
+     *
+     * Returns a [`CancelTransition`] that, once persisted, yields the fallback
+     * transaction when applicable. The fallback transaction is the sender's original
+     * transaction that should be broadcast to complete the payment without Payjoin.
+     *
+     * This is a terminal transition — the session cannot be used after cancellation.
+     */
+    cancel(): CancelTransitionInterface;
     /**
      * Find which outputs belong to the receiver
      */
@@ -2673,6 +4871,16 @@ export declare class OutputsUnknown extends UniffiAbstractObject implements Outp
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
+    /**
+     * Cancel the Payjoin session immediately.
+     *
+     * Returns a [`CancelTransition`] that, once persisted, yields the fallback
+     * transaction when applicable. The fallback transaction is the sender's original
+     * transaction that should be broadcast to complete the payment without Payjoin.
+     *
+     * This is a terminal transition — the session cannot be used after cancellation.
+     */
+    cancel(): CancelTransitionInterface;
     /**
      * Find which outputs belong to the receiver
      */
@@ -2685,6 +4893,9 @@ export declare class OutputsUnknown extends UniffiAbstractObject implements Outp
 }
 export interface OutputsUnknownTransitionInterface {
     save(persister: JsonReceiverSessionPersister): WantsOutputsInterface;
+    saveAsync(persister: JsonReceiverSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<WantsOutputsInterface>;
 }
 export declare class OutputsUnknownTransition extends UniffiAbstractObject implements OutputsUnknownTransitionInterface {
     readonly [uniffiTypeNameSymbol] = "OutputsUnknownTransition";
@@ -2692,6 +4903,9 @@ export declare class OutputsUnknownTransition extends UniffiAbstractObject imple
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
     save(persister: JsonReceiverSessionPersister): WantsOutputsInterface;
+    saveAsync(persister: JsonReceiverSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<WantsOutputsInterface>;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -2699,6 +4913,16 @@ export declare class OutputsUnknownTransition extends UniffiAbstractObject imple
     static instanceOf(obj: any): obj is OutputsUnknownTransition;
 }
 export interface PayjoinProposalInterface {
+    /**
+     * Cancel the Payjoin session immediately.
+     *
+     * Returns a [`CancelTransition`] that, once persisted, yields the fallback
+     * transaction when applicable. The fallback transaction is the sender's original
+     * transaction that should be broadcast to complete the payment without Payjoin.
+     *
+     * This is a terminal transition — the session cannot be used after cancellation.
+     */
+    cancel(): CancelTransitionInterface;
     /**
      * Construct an OHTTP Encapsulated HTTP POST request for the Proposal PSBT
      */
@@ -2712,13 +4936,23 @@ export interface PayjoinProposalInterface {
      */
     processResponse(body: ArrayBuffer, ohttpContext: ClientResponseInterface): PayjoinProposalTransitionInterface;
     psbt(): string;
-    utxosToBeLocked(): Array<OutPoint>;
+    utxosToBeLocked(): Array<PlainOutPoint>;
 }
 export declare class PayjoinProposal extends UniffiAbstractObject implements PayjoinProposalInterface {
     readonly [uniffiTypeNameSymbol] = "PayjoinProposal";
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
+    /**
+     * Cancel the Payjoin session immediately.
+     *
+     * Returns a [`CancelTransition`] that, once persisted, yields the fallback
+     * transaction when applicable. The fallback transaction is the sender's original
+     * transaction that should be broadcast to complete the payment without Payjoin.
+     *
+     * This is a terminal transition — the session cannot be used after cancellation.
+     */
+    cancel(): CancelTransitionInterface;
     /**
      * Construct an OHTTP Encapsulated HTTP POST request for the Proposal PSBT
      */
@@ -2732,7 +4966,7 @@ export declare class PayjoinProposal extends UniffiAbstractObject implements Pay
      */
     processResponse(body: ArrayBuffer, ohttpContext: ClientResponseInterface): PayjoinProposalTransitionInterface;
     psbt(): string;
-    utxosToBeLocked(): Array<OutPoint>;
+    utxosToBeLocked(): Array<PlainOutPoint>;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -2741,6 +4975,9 @@ export declare class PayjoinProposal extends UniffiAbstractObject implements Pay
 }
 export interface PayjoinProposalTransitionInterface {
     save(persister: JsonReceiverSessionPersister): MonitorInterface;
+    saveAsync(persister: JsonReceiverSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<MonitorInterface>;
 }
 export declare class PayjoinProposalTransition extends UniffiAbstractObject implements PayjoinProposalTransitionInterface {
     readonly [uniffiTypeNameSymbol] = "PayjoinProposalTransition";
@@ -2748,6 +4985,9 @@ export declare class PayjoinProposalTransition extends UniffiAbstractObject impl
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
     save(persister: JsonReceiverSessionPersister): MonitorInterface;
+    saveAsync(persister: JsonReceiverSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<MonitorInterface>;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -2761,6 +5001,27 @@ export declare class PjNotSupported extends UniffiAbstractObject implements PjNo
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
+    /**
+     * Calls into the `Debug` string representation of `PjNotSupportedInterface` (the native Rust peer).
+     *
+     * Generated by deriving the `Debug` trait in Rust.
+     */
+    toDebugString(): string;
+    /**
+     * Calls into the `PjNotSupportedInterface::to_string()` method of the native Rust peer.
+     *
+     * Generated by deriving the `Display` trait in Rust.
+     */
+    toString(): string;
+    /**
+     * Calls into the `==` method of `PjNotSupportedInterface` (the native Rust peer).
+     *
+     * Returns `true` if and only if the two instance of `PjNotSupportedInterface` are
+     * equivalent on the Rust side.
+     *
+     * Generated by deriving the `Eq` trait in Rust.
+     */
+    equals(other: PjNotSupported): boolean;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -2789,6 +5050,27 @@ export declare class PjParseError extends UniffiAbstractObject implements PjPars
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
+    /**
+     * Calls into the `Debug` string representation of `PjParseErrorInterface` (the native Rust peer).
+     *
+     * Generated by deriving the `Debug` trait in Rust.
+     */
+    toDebugString(): string;
+    /**
+     * Calls into the `PjParseErrorInterface::to_string()` method of the native Rust peer.
+     *
+     * Generated by deriving the `Display` trait in Rust.
+     */
+    toString(): string;
+    /**
+     * Calls into the `==` method of `PjParseErrorInterface` (the native Rust peer).
+     *
+     * Returns `true` if and only if the two instance of `PjParseErrorInterface` are
+     * equivalent on the Rust side.
+     *
+     * Generated by deriving the `Eq` trait in Rust.
+     */
+    equals(other: PjParseError): boolean;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -2833,6 +5115,16 @@ export declare class PjUri extends UniffiAbstractObject implements PjUriInterfac
     static instanceOf(obj: any): obj is PjUri;
 }
 export interface PollingForProposalInterface {
+    /**
+     * Cancel the Payjoin session immediately.
+     *
+     * Returns a [`SenderCancelTransition`] that, once persisted, yields the fallback
+     * transaction. The fallback transaction is the sender's original transaction
+     * that should be broadcast to complete the payment without Payjoin.
+     *
+     * This is a terminal transition — the session cannot be used after cancellation.
+     */
+    cancel(): SenderCancelTransitionInterface;
     createPollRequest(ohttpRelay: string): RequestOhttpContext;
     /**
      * Decodes and validates the response.
@@ -2846,6 +5138,16 @@ export declare class PollingForProposal extends UniffiAbstractObject implements
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
+    /**
+     * Cancel the Payjoin session immediately.
+     *
+     * Returns a [`SenderCancelTransition`] that, once persisted, yields the fallback
+     * transaction. The fallback transaction is the sender's original transaction
+     * that should be broadcast to complete the payment without Payjoin.
+     *
+     * This is a terminal transition — the session cannot be used after cancellation.
+     */
+    cancel(): SenderCancelTransitionInterface;
     createPollRequest(ohttpRelay: string): RequestOhttpContext;
     /**
      * Decodes and validates the response.
@@ -2861,6 +5163,9 @@ export declare class PollingForProposal extends UniffiAbstractObject implements
 }
 export interface PollingForProposalTransitionInterface {
     save(persister: JsonSenderSessionPersister): PollingForProposalTransitionOutcome;
+    saveAsync(persister: JsonSenderSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<PollingForProposalTransitionOutcome>;
 }
 export declare class PollingForProposalTransition extends UniffiAbstractObject implements PollingForProposalTransitionInterface {
     readonly [uniffiTypeNameSymbol] = "PollingForProposalTransition";
@@ -2868,6 +5173,9 @@ export declare class PollingForProposalTransition extends UniffiAbstractObject i
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
     save(persister: JsonSenderSessionPersister): PollingForProposalTransitionOutcome;
+    saveAsync(persister: JsonSenderSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<PollingForProposalTransitionOutcome>;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -2918,6 +5226,18 @@ export declare class ProtocolError extends UniffiAbstractObject implements Proto
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
+    /**
+     * Calls into the `Debug` string representation of `ProtocolErrorInterface` (the native Rust peer).
+     *
+     * Generated by deriving the `Debug` trait in Rust.
+     */
+    toDebugString(): string;
+    /**
+     * Calls into the `ProtocolErrorInterface::to_string()` method of the native Rust peer.
+     *
+     * Generated by deriving the `Display` trait in Rust.
+     */
+    toString(): string;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -2925,16 +5245,36 @@ export declare class ProtocolError extends UniffiAbstractObject implements Proto
     static instanceOf(obj: any): obj is ProtocolError;
 }
 export interface ProvisionalProposalInterface {
+    /**
+     * Cancel the Payjoin session immediately.
+     *
+     * Returns a [`CancelTransition`] that, once persisted, yields the fallback
+     * transaction when applicable. The fallback transaction is the sender's original
+     * transaction that should be broadcast to complete the payment without Payjoin.
+     *
+     * This is a terminal transition — the session cannot be used after cancellation.
+     */
+    cancel(): CancelTransitionInterface;
     finalizeProposal(processPsbt: ProcessPsbt): ProvisionalProposalTransitionInterface;
-    psbtToSign(): PsbtInterface;
+    psbtToSign(): string;
 }
 export declare class ProvisionalProposal extends UniffiAbstractObject implements ProvisionalProposalInterface {
     readonly [uniffiTypeNameSymbol] = "ProvisionalProposal";
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
+    /**
+     * Cancel the Payjoin session immediately.
+     *
+     * Returns a [`CancelTransition`] that, once persisted, yields the fallback
+     * transaction when applicable. The fallback transaction is the sender's original
+     * transaction that should be broadcast to complete the payment without Payjoin.
+     *
+     * This is a terminal transition — the session cannot be used after cancellation.
+     */
+    cancel(): CancelTransitionInterface;
     finalizeProposal(processPsbt: ProcessPsbt): ProvisionalProposalTransitionInterface;
-    psbtToSign(): PsbtInterface;
+    psbtToSign(): string;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -2943,6 +5283,9 @@ export declare class ProvisionalProposal extends UniffiAbstractObject implements
 }
 export interface ProvisionalProposalTransitionInterface {
     save(persister: JsonReceiverSessionPersister): PayjoinProposalInterface;
+    saveAsync(persister: JsonReceiverSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<PayjoinProposalInterface>;
 }
 export declare class ProvisionalProposalTransition extends UniffiAbstractObject implements ProvisionalProposalTransitionInterface {
     readonly [uniffiTypeNameSymbol] = "ProvisionalProposalTransition";
@@ -2950,6 +5293,9 @@ export declare class ProvisionalProposalTransition extends UniffiAbstractObject
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
     save(persister: JsonReceiverSessionPersister): PayjoinProposalInterface;
+    saveAsync(persister: JsonReceiverSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<PayjoinProposalInterface>;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -2969,13 +5315,23 @@ export declare class PsbtInputError extends UniffiAbstractObject implements Psbt
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
+    /**
+     * Calls into the `Debug` string representation of `PsbtInputErrorInterface` (the native Rust peer).
+     *
+     * Generated by deriving the `Debug` trait in Rust.
+     */
+    toDebugString(): string;
+    /**
+     * Calls into the `PsbtInputErrorInterface::to_string()` method of the native Rust peer.
+     *
+     * Generated by deriving the `Display` trait in Rust.
+     */
+    toString(): string;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
     uniffiDestroy(): void;
     static instanceOf(obj: any): obj is PsbtInputError;
-    static hasInner(obj: any): obj is UniffiThrownObject<PsbtInputError>;
-    static getInner(err: UniffiThrownObject<PsbtInputError>): PsbtInputError;
 }
 export interface ReceiverBuilderInterface {
     build(): InitialReceiveTransitionInterface;
@@ -3001,7 +5357,7 @@ export declare class ReceiverBuilder extends UniffiAbstractObject implements Rec
      * # References
      * - [BIP 77: Payjoin Version 2: Serverless Payjoin](https://github.com/bitcoin/bips/blob/master/bip-0077.md)
      */
-    constructor(address: AddressInterface, directory: string, ohttpKeys: OhttpKeysInterface);
+    constructor(address: string, directory: string, ohttpKeys: OhttpKeysInterface);
     build(): InitialReceiveTransitionInterface;
     withAmount(amountSats: bigint): ReceiverBuilderInterface;
     withExpiration(expiration: bigint): ReceiverBuilderInterface;
@@ -3028,6 +5384,18 @@ export declare class ReceiverReplayError extends UniffiAbstractObject implements
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
+    /**
+     * Calls into the `Debug` string representation of `ReceiverReplayErrorInterface` (the native Rust peer).
+     *
+     * Generated by deriving the `Debug` trait in Rust.
+     */
+    toDebugString(): string;
+    /**
+     * Calls into the `ReceiverReplayErrorInterface::to_string()` method of the native Rust peer.
+     *
+     * Generated by deriving the `Display` trait in Rust.
+     */
+    toString(): string;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -3056,7 +5424,7 @@ export interface ReceiverSessionHistoryInterface {
     /**
      * Fallback transaction from the session if present
      */
-    fallbackTx(): TransactionInterface | undefined;
+    fallbackTx(): ArrayBuffer | undefined;
     /**
      * Receiver session Payjoin URI
      */
@@ -3074,7 +5442,7 @@ export declare class ReceiverSessionHistory extends UniffiAbstractObject impleme
     /**
      * Fallback transaction from the session if present
      */
-    fallbackTx(): TransactionInterface | undefined;
+    fallbackTx(): ArrayBuffer | undefined;
     /**
      * Receiver session Payjoin URI
      */
@@ -3153,6 +5521,18 @@ export declare class SelectionError extends UniffiAbstractObject implements Sele
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
+    /**
+     * Calls into the `Debug` string representation of `SelectionErrorInterface` (the native Rust peer).
+     *
+     * Generated by deriving the `Debug` trait in Rust.
+     */
+    toDebugString(): string;
+    /**
+     * Calls into the `SelectionErrorInterface::to_string()` method of the native Rust peer.
+     *
+     * Generated by deriving the `Display` trait in Rust.
+     */
+    toString(): string;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -3256,6 +5636,47 @@ export declare class SenderBuilder extends UniffiAbstractObject implements Sende
     uniffiDestroy(): void;
     static instanceOf(obj: any): obj is SenderBuilder;
 }
+/**
+ * A terminal transition produced by cancelling a sender session.
+ */
+export interface SenderCancelTransitionInterface {
+    /**
+     * Persist the cancellation and return the fallback transaction.
+     *
+     * The fallback transaction is the consensus-encoded raw transaction bytes of
+     * the sender's original transaction that should be broadcast to complete the
+     * payment without Payjoin.
+     */
+    save(persister: JsonSenderSessionPersister): ArrayBuffer;
+    saveAsync(persister: JsonSenderSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ArrayBuffer>;
+}
+/**
+ * A terminal transition produced by cancelling a sender session.
+ */
+export declare class SenderCancelTransition extends UniffiAbstractObject implements SenderCancelTransitionInterface {
+    readonly [uniffiTypeNameSymbol] = "SenderCancelTransition";
+    readonly [destructorGuardSymbol]: UniffiRustArcPtr;
+    readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
+    private constructor();
+    /**
+     * Persist the cancellation and return the fallback transaction.
+     *
+     * The fallback transaction is the consensus-encoded raw transaction bytes of
+     * the sender's original transaction that should be broadcast to complete the
+     * payment without Payjoin.
+     */
+    save(persister: JsonSenderSessionPersister): ArrayBuffer;
+    saveAsync(persister: JsonSenderSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ArrayBuffer>;
+    /**
+     * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+     */
+    uniffiDestroy(): void;
+    static instanceOf(obj: any): obj is SenderCancelTransition;
+}
 /**
  * Error that may occur when the sender session event log is replayed
  */
@@ -3269,6 +5690,18 @@ export declare class SenderReplayError extends UniffiAbstractObject implements S
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
+    /**
+     * Calls into the `Debug` string representation of `SenderReplayErrorInterface` (the native Rust peer).
+     *
+     * Generated by deriving the `Debug` trait in Rust.
+     */
+    toDebugString(): string;
+    /**
+     * Calls into the `SenderReplayErrorInterface::to_string()` method of the native Rust peer.
+     *
+     * Generated by deriving the `Display` trait in Rust.
+     */
+    toString(): string;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -3314,7 +5747,7 @@ export interface SenderSessionHistoryInterface {
     /**
      * Fallback transaction from the session if present
      */
-    fallbackTx(): TransactionInterface;
+    fallbackTx(): ArrayBuffer;
     pjParam(): PjParamInterface;
     status(): SenderSessionStatusInterface;
 }
@@ -3326,7 +5759,7 @@ export declare class SenderSessionHistory extends UniffiAbstractObject implement
     /**
      * Fallback transaction from the session if present
      */
-    fallbackTx(): TransactionInterface;
+    fallbackTx(): ArrayBuffer;
     pjParam(): PjParamInterface;
     status(): SenderSessionStatusInterface;
     /**
@@ -3336,12 +5769,20 @@ export declare class SenderSessionHistory extends UniffiAbstractObject implement
     static instanceOf(obj: any): obj is SenderSessionHistory;
 }
 export interface SenderSessionOutcomeInterface {
+    isCancelled(): boolean;
+    isFailure(): boolean;
+    isSuccess(): boolean;
+    successPsbtBase64(): string | undefined;
 }
 export declare class SenderSessionOutcome extends UniffiAbstractObject implements SenderSessionOutcomeInterface {
     readonly [uniffiTypeNameSymbol] = "SenderSessionOutcome";
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
+    isCancelled(): boolean;
+    isFailure(): boolean;
+    isSuccess(): boolean;
+    successPsbtBase64(): string | undefined;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -3376,6 +5817,18 @@ export declare class SerdeJsonError extends UniffiAbstractObject implements Serd
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
+    /**
+     * Calls into the `Debug` string representation of `SerdeJsonErrorInterface` (the native Rust peer).
+     *
+     * Generated by deriving the `Debug` trait in Rust.
+     */
+    toDebugString(): string;
+    /**
+     * Calls into the `SerdeJsonErrorInterface::to_string()` method of the native Rust peer.
+     *
+     * Generated by deriving the `Display` trait in Rust.
+     */
+    toString(): string;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -3397,6 +5850,18 @@ export declare class SessionError extends UniffiAbstractObject implements Sessio
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
+    /**
+     * Calls into the `Debug` string representation of `SessionErrorInterface` (the native Rust peer).
+     *
+     * Generated by deriving the `Debug` trait in Rust.
+     */
+    toDebugString(): string;
+    /**
+     * Calls into the `SessionErrorInterface::to_string()` method of the native Rust peer.
+     *
+     * Generated by deriving the `Display` trait in Rust.
+     */
+    toString(): string;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -3429,6 +5894,16 @@ export interface UncheckedOriginalPayloadInterface {
      * Those receivers call `extract_tx_to_check_broadcast()` and `attest_tested_and_scheduled_broadcast()` after making those checks downstream.
      */
     assumeInteractiveReceiver(): AssumeInteractiveTransitionInterface;
+    /**
+     * Cancel the Payjoin session immediately.
+     *
+     * Returns a [`CancelTransition`] that, once persisted, yields the fallback
+     * transaction when applicable. The fallback transaction is the sender's original
+     * transaction that should be broadcast to complete the payment without Payjoin.
+     *
+     * This is a terminal transition — the session cannot be used after cancellation.
+     */
+    cancel(): CancelTransitionInterface;
     checkBroadcastSuitability(minFeeRate: /*u64*/ bigint | undefined, canBroadcast: CanBroadcast): UncheckedOriginalPayloadTransitionInterface;
 }
 export declare class UncheckedOriginalPayload extends UniffiAbstractObject implements UncheckedOriginalPayloadInterface {
@@ -3444,6 +5919,16 @@ export declare class UncheckedOriginalPayload extends UniffiAbstractObject imple
      * Those receivers call `extract_tx_to_check_broadcast()` and `attest_tested_and_scheduled_broadcast()` after making those checks downstream.
      */
     assumeInteractiveReceiver(): AssumeInteractiveTransitionInterface;
+    /**
+     * Cancel the Payjoin session immediately.
+     *
+     * Returns a [`CancelTransition`] that, once persisted, yields the fallback
+     * transaction when applicable. The fallback transaction is the sender's original
+     * transaction that should be broadcast to complete the payment without Payjoin.
+     *
+     * This is a terminal transition — the session cannot be used after cancellation.
+     */
+    cancel(): CancelTransitionInterface;
     checkBroadcastSuitability(minFeeRate: /*u64*/ bigint | undefined, canBroadcast: CanBroadcast): UncheckedOriginalPayloadTransitionInterface;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
@@ -3453,6 +5938,9 @@ export declare class UncheckedOriginalPayload extends UniffiAbstractObject imple
 }
 export interface UncheckedOriginalPayloadTransitionInterface {
     save(persister: JsonReceiverSessionPersister): MaybeInputsOwnedInterface;
+    saveAsync(persister: JsonReceiverSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<MaybeInputsOwnedInterface>;
 }
 export declare class UncheckedOriginalPayloadTransition extends UniffiAbstractObject implements UncheckedOriginalPayloadTransitionInterface {
     readonly [uniffiTypeNameSymbol] = "UncheckedOriginalPayloadTransition";
@@ -3460,6 +5948,9 @@ export declare class UncheckedOriginalPayloadTransition extends UniffiAbstractOb
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
     save(persister: JsonReceiverSessionPersister): MaybeInputsOwnedInterface;
+    saveAsync(persister: JsonReceiverSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<MaybeInputsOwnedInterface>;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -3523,6 +6014,18 @@ export declare class UrlParseError extends UniffiAbstractObject implements UrlPa
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
+    /**
+     * Calls into the `Debug` string representation of `UrlParseErrorInterface` (the native Rust peer).
+     *
+     * Generated by deriving the `Debug` trait in Rust.
+     */
+    toDebugString(): string;
+    /**
+     * Calls into the `UrlParseErrorInterface::to_string()` method of the native Rust peer.
+     *
+     * Generated by deriving the `Display` trait in Rust.
+     */
+    toString(): string;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -3575,6 +6078,18 @@ export declare class ValidationError extends UniffiAbstractObject implements Val
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
+    /**
+     * Calls into the `Debug` string representation of `ValidationErrorInterface` (the native Rust peer).
+     *
+     * Generated by deriving the `Debug` trait in Rust.
+     */
+    toDebugString(): string;
+    /**
+     * Calls into the `ValidationErrorInterface::to_string()` method of the native Rust peer.
+     *
+     * Generated by deriving the `Display` trait in Rust.
+     */
+    toString(): string;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -3605,6 +6120,16 @@ export interface WantsFeeRangeInterface {
      * the original proposal parameters and the limit passed in the `min_fee_rate_sat_per_vb` parameter.
      */
     applyFeeRange(minFeeRateSatPerVb: /*u64*/ bigint | undefined, maxEffectiveFeeRateSatPerVb: /*u64*/ bigint | undefined): WantsFeeRangeTransitionInterface;
+    /**
+     * Cancel the Payjoin session immediately.
+     *
+     * Returns a [`CancelTransition`] that, once persisted, yields the fallback
+     * transaction when applicable. The fallback transaction is the sender's original
+     * transaction that should be broadcast to complete the payment without Payjoin.
+     *
+     * This is a terminal transition — the session cannot be used after cancellation.
+     */
+    cancel(): CancelTransitionInterface;
 }
 export declare class WantsFeeRange extends UniffiAbstractObject implements WantsFeeRangeInterface {
     readonly [uniffiTypeNameSymbol] = "WantsFeeRange";
@@ -3634,6 +6159,16 @@ export declare class WantsFeeRange extends UniffiAbstractObject implements Wants
      * the original proposal parameters and the limit passed in the `min_fee_rate_sat_per_vb` parameter.
      */
     applyFeeRange(minFeeRateSatPerVb: /*u64*/ bigint | undefined, maxEffectiveFeeRateSatPerVb: /*u64*/ bigint | undefined): WantsFeeRangeTransitionInterface;
+    /**
+     * Cancel the Payjoin session immediately.
+     *
+     * Returns a [`CancelTransition`] that, once persisted, yields the fallback
+     * transaction when applicable. The fallback transaction is the sender's original
+     * transaction that should be broadcast to complete the payment without Payjoin.
+     *
+     * This is a terminal transition — the session cannot be used after cancellation.
+     */
+    cancel(): CancelTransitionInterface;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -3642,6 +6177,9 @@ export declare class WantsFeeRange extends UniffiAbstractObject implements Wants
 }
 export interface WantsFeeRangeTransitionInterface {
     save(persister: JsonReceiverSessionPersister): ProvisionalProposalInterface;
+    saveAsync(persister: JsonReceiverSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ProvisionalProposalInterface>;
 }
 export declare class WantsFeeRangeTransition extends UniffiAbstractObject implements WantsFeeRangeTransitionInterface {
     readonly [uniffiTypeNameSymbol] = "WantsFeeRangeTransition";
@@ -3649,6 +6187,9 @@ export declare class WantsFeeRangeTransition extends UniffiAbstractObject implem
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
     save(persister: JsonReceiverSessionPersister): ProvisionalProposalInterface;
+    saveAsync(persister: JsonReceiverSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<ProvisionalProposalInterface>;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -3656,6 +6197,16 @@ export declare class WantsFeeRangeTransition extends UniffiAbstractObject implem
     static instanceOf(obj: any): obj is WantsFeeRangeTransition;
 }
 export interface WantsInputsInterface {
+    /**
+     * Cancel the Payjoin session immediately.
+     *
+     * Returns a [`CancelTransition`] that, once persisted, yields the fallback
+     * transaction when applicable. The fallback transaction is the sender's original
+     * transaction that should be broadcast to complete the payment without Payjoin.
+     *
+     * This is a terminal transition — the session cannot be used after cancellation.
+     */
+    cancel(): CancelTransitionInterface;
     commitInputs(): WantsInputsTransitionInterface;
     contributeInputs(replacementInputs: Array<InputPairInterface>): WantsInputsInterface;
     /**
@@ -3676,6 +6227,16 @@ export declare class WantsInputs extends UniffiAbstractObject implements WantsIn
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
+    /**
+     * Cancel the Payjoin session immediately.
+     *
+     * Returns a [`CancelTransition`] that, once persisted, yields the fallback
+     * transaction when applicable. The fallback transaction is the sender's original
+     * transaction that should be broadcast to complete the payment without Payjoin.
+     *
+     * This is a terminal transition — the session cannot be used after cancellation.
+     */
+    cancel(): CancelTransitionInterface;
     commitInputs(): WantsInputsTransitionInterface;
     contributeInputs(replacementInputs: Array<InputPairInterface>): WantsInputsInterface;
     /**
@@ -3698,6 +6259,9 @@ export declare class WantsInputs extends UniffiAbstractObject implements WantsIn
 }
 export interface WantsInputsTransitionInterface {
     save(persister: JsonReceiverSessionPersister): WantsFeeRangeInterface;
+    saveAsync(persister: JsonReceiverSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<WantsFeeRangeInterface>;
 }
 export declare class WantsInputsTransition extends UniffiAbstractObject implements WantsInputsTransitionInterface {
     readonly [uniffiTypeNameSymbol] = "WantsInputsTransition";
@@ -3705,6 +6269,9 @@ export declare class WantsInputsTransition extends UniffiAbstractObject implemen
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
     save(persister: JsonReceiverSessionPersister): WantsFeeRangeInterface;
+    saveAsync(persister: JsonReceiverSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<WantsFeeRangeInterface>;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -3712,20 +6279,40 @@ export declare class WantsInputsTransition extends UniffiAbstractObject implemen
     static instanceOf(obj: any): obj is WantsInputsTransition;
 }
 export interface WantsOutputsInterface {
+    /**
+     * Cancel the Payjoin session immediately.
+     *
+     * Returns a [`CancelTransition`] that, once persisted, yields the fallback
+     * transaction when applicable. The fallback transaction is the sender's original
+     * transaction that should be broadcast to complete the payment without Payjoin.
+     *
+     * This is a terminal transition — the session cannot be used after cancellation.
+     */
+    cancel(): CancelTransitionInterface;
     commitOutputs(): WantsOutputsTransitionInterface;
     outputSubstitution(): OutputSubstitution;
-    replaceReceiverOutputs(replacementOutputs: Array<TxOut>, drainScript: ScriptInterface): WantsOutputsInterface;
-    substituteReceiverScript(outputScript: ScriptInterface): WantsOutputsInterface;
+    replaceReceiverOutputs(replacementOutputs: Array<PlainTxOut>, drainScriptPubkey: ArrayBuffer): WantsOutputsInterface;
+    substituteReceiverScript(outputScriptPubkey: ArrayBuffer): WantsOutputsInterface;
 }
 export declare class WantsOutputs extends UniffiAbstractObject implements WantsOutputsInterface {
     readonly [uniffiTypeNameSymbol] = "WantsOutputs";
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
+    /**
+     * Cancel the Payjoin session immediately.
+     *
+     * Returns a [`CancelTransition`] that, once persisted, yields the fallback
+     * transaction when applicable. The fallback transaction is the sender's original
+     * transaction that should be broadcast to complete the payment without Payjoin.
+     *
+     * This is a terminal transition — the session cannot be used after cancellation.
+     */
+    cancel(): CancelTransitionInterface;
     commitOutputs(): WantsOutputsTransitionInterface;
     outputSubstitution(): OutputSubstitution;
-    replaceReceiverOutputs(replacementOutputs: Array<TxOut>, drainScript: ScriptInterface): WantsOutputsInterface;
-    substituteReceiverScript(outputScript: ScriptInterface): WantsOutputsInterface;
+    replaceReceiverOutputs(replacementOutputs: Array<PlainTxOut>, drainScriptPubkey: ArrayBuffer): WantsOutputsInterface;
+    substituteReceiverScript(outputScriptPubkey: ArrayBuffer): WantsOutputsInterface;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -3734,6 +6321,9 @@ export declare class WantsOutputs extends UniffiAbstractObject implements WantsO
 }
 export interface WantsOutputsTransitionInterface {
     save(persister: JsonReceiverSessionPersister): WantsInputsInterface;
+    saveAsync(persister: JsonReceiverSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<WantsInputsInterface>;
 }
 export declare class WantsOutputsTransition extends UniffiAbstractObject implements WantsOutputsTransitionInterface {
     readonly [uniffiTypeNameSymbol] = "WantsOutputsTransition";
@@ -3741,6 +6331,9 @@ export declare class WantsOutputsTransition extends UniffiAbstractObject impleme
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
     save(persister: JsonReceiverSessionPersister): WantsInputsInterface;
+    saveAsync(persister: JsonReceiverSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<WantsInputsInterface>;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -3760,6 +6353,18 @@ export declare class WellKnownError extends UniffiAbstractObject implements Well
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
+    /**
+     * Calls into the `Debug` string representation of `WellKnownErrorInterface` (the native Rust peer).
+     *
+     * Generated by deriving the `Debug` trait in Rust.
+     */
+    toDebugString(): string;
+    /**
+     * Calls into the `WellKnownErrorInterface::to_string()` method of the native Rust peer.
+     *
+     * Generated by deriving the `Display` trait in Rust.
+     */
+    toString(): string;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -3767,6 +6372,16 @@ export declare class WellKnownError extends UniffiAbstractObject implements Well
     static instanceOf(obj: any): obj is WellKnownError;
 }
 export interface WithReplyKeyInterface {
+    /**
+     * Cancel the Payjoin session immediately.
+     *
+     * Returns a [`SenderCancelTransition`] that, once persisted, yields the fallback
+     * transaction. The fallback transaction is the sender's original transaction
+     * that should be broadcast to complete the payment without Payjoin.
+     *
+     * This is a terminal transition — the session cannot be used after cancellation.
+     */
+    cancel(): SenderCancelTransitionInterface;
     /**
      * Construct serialized Request and Context from a Payjoin Proposal.
      *
@@ -3787,6 +6402,16 @@ export declare class WithReplyKey extends UniffiAbstractObject implements WithRe
     readonly [destructorGuardSymbol]: UniffiRustArcPtr;
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
+    /**
+     * Cancel the Payjoin session immediately.
+     *
+     * Returns a [`SenderCancelTransition`] that, once persisted, yields the fallback
+     * transaction. The fallback transaction is the sender's original transaction
+     * that should be broadcast to complete the payment without Payjoin.
+     *
+     * This is a terminal transition — the session cannot be used after cancellation.
+     */
+    cancel(): SenderCancelTransitionInterface;
     /**
      * Construct serialized Request and Context from a Payjoin Proposal.
      *
@@ -3809,6 +6434,9 @@ export declare class WithReplyKey extends UniffiAbstractObject implements WithRe
 }
 export interface WithReplyKeyTransitionInterface {
     save(persister: JsonSenderSessionPersister): PollingForProposalInterface;
+    saveAsync(persister: JsonSenderSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<PollingForProposalInterface>;
 }
 export declare class WithReplyKeyTransition extends UniffiAbstractObject implements WithReplyKeyTransitionInterface {
     readonly [uniffiTypeNameSymbol] = "WithReplyKeyTransition";
@@ -3816,6 +6444,9 @@ export declare class WithReplyKeyTransition extends UniffiAbstractObject impleme
     readonly [pointerLiteralSymbol]: UnsafeMutableRawPointer;
     private constructor();
     save(persister: JsonSenderSessionPersister): PollingForProposalInterface;
+    saveAsync(persister: JsonSenderSessionPersisterAsync, asyncOpts_?: {
+        signal: AbortSignal;
+    }): Promise<PollingForProposalInterface>;
     /**
      * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
      */
@@ -3836,16 +6467,24 @@ declare function uniffiEnsureInitialized(): void;
 declare const _default: Readonly<{
     initialize: typeof uniffiEnsureInitialized;
     converters: {
+        FfiConverterTypeAddressParseError: FfiConverterObject<AddressParseErrorInterface>;
         FfiConverterTypeAssumeInteractiveTransition: FfiConverterObject<AssumeInteractiveTransitionInterface>;
         FfiConverterTypeBuildSenderError: FfiConverterObject<BuildSenderErrorInterface>;
-        FfiConverterTypeBuildSenderError__as_error: FfiConverterObjectAsError<BuildSenderErrorInterface>;
         FfiConverterTypeCanBroadcast: FfiConverterObjectWithCallbacks<CanBroadcast>;
+        FfiConverterTypeCancelTransition: FfiConverterObject<CancelTransitionInterface>;
         FfiConverterTypeClientResponse: FfiConverterObject<ClientResponseInterface>;
         FfiConverterTypeCreateRequestError: FfiConverterObject<CreateRequestErrorInterface>;
         FfiConverterTypeCreateRequestError__as_error: FfiConverterObjectAsError<CreateRequestErrorInterface>;
         FfiConverterTypeEncapsulationError: FfiConverterObject<EncapsulationErrorInterface>;
         FfiConverterTypeFeeRateError: FfiConverterObject<FeeRateErrorInterface>;
         FfiConverterTypeFeeRateError__as_error: FfiConverterObjectAsError<FeeRateErrorInterface>;
+        FfiConverterTypeFfiValidationError: {
+            read(from: RustBuffer): FfiValidationError;
+            write(value: FfiValidationError, into: RustBuffer): void;
+            allocationSize(value: FfiValidationError): number;
+            lift(value: UniffiByteArray): FfiValidationError;
+            lower(value: FfiValidationError): UniffiByteArray;
+        };
         FfiConverterTypeForeignError: {
             read(from: RustBuffer): {
                 readonly tag: ForeignError_Tags.InternalError;
@@ -3930,13 +6569,21 @@ declare const _default: Readonly<{
         FfiConverterTypeInputContributionError: FfiConverterObject<InputContributionErrorInterface>;
         FfiConverterTypeInputContributionError__as_error: FfiConverterObjectAsError<InputContributionErrorInterface>;
         FfiConverterTypeInputPair: FfiConverterObject<InputPairInterface>;
+        FfiConverterTypeInputPairError: {
+            read(from: RustBuffer): InputPairError;
+            write(value: InputPairError, into: RustBuffer): void;
+            allocationSize(value: InputPairError): number;
+            lift(value: UniffiByteArray): InputPairError;
+            lower(value: InputPairError): UniffiByteArray;
+        };
         FfiConverterTypeIntoUrlError: FfiConverterObject<IntoUrlErrorInterface>;
-        FfiConverterTypeIntoUrlError__as_error: FfiConverterObjectAsError<IntoUrlErrorInterface>;
         FfiConverterTypeIsOutputKnown: FfiConverterObjectWithCallbacks<IsOutputKnown>;
         FfiConverterTypeIsScriptOwned: FfiConverterObjectWithCallbacks<IsScriptOwned>;
         FfiConverterTypeJsonReceiverSessionPersister: FfiConverterObjectWithCallbacks<JsonReceiverSessionPersister>;
+        FfiConverterTypeJsonReceiverSessionPersisterAsync: FfiConverterObjectWithCallbacks<JsonReceiverSessionPersisterAsync>;
         FfiConverterTypeJsonReply: FfiConverterObject<JsonReplyInterface>;
         FfiConverterTypeJsonSenderSessionPersister: FfiConverterObjectWithCallbacks<JsonSenderSessionPersister>;
+        FfiConverterTypeJsonSenderSessionPersisterAsync: FfiConverterObjectWithCallbacks<JsonSenderSessionPersisterAsync>;
         FfiConverterTypeMaybeInputsOwned: FfiConverterObject<MaybeInputsOwnedInterface>;
         FfiConverterTypeMaybeInputsOwnedTransition: FfiConverterObject<MaybeInputsOwnedTransitionInterface>;
         FfiConverterTypeMaybeInputsSeen: FfiConverterObject<MaybeInputsSeenInterface>;
@@ -3946,7 +6593,6 @@ declare const _default: Readonly<{
         FfiConverterTypeOhttpError: FfiConverterObject<OhttpErrorInterface>;
         FfiConverterTypeOhttpError__as_error: FfiConverterObjectAsError<OhttpErrorInterface>;
         FfiConverterTypeOhttpKeys: FfiConverterObject<OhttpKeysInterface>;
-        FfiConverterTypeOutpointSpent: FfiConverterObjectWithCallbacks<OutpointSpent>;
         FfiConverterTypeOutputSubstitution: {
             read(from: RustBuffer): OutputSubstitution;
             write(value: OutputSubstitution, into: RustBuffer): void;
@@ -3954,8 +6600,14 @@ declare const _default: Readonly<{
             lift(value: UniffiByteArray): OutputSubstitution;
             lower(value: OutputSubstitution): UniffiByteArray;
         };
-        FfiConverterTypeOutputSubstitutionError: FfiConverterObject<OutputSubstitutionErrorInterface>;
-        FfiConverterTypeOutputSubstitutionError__as_error: FfiConverterObjectAsError<OutputSubstitutionErrorInterface>;
+        FfiConverterTypeOutputSubstitutionError: {
+            read(from: RustBuffer): OutputSubstitutionError;
+            write(value: OutputSubstitutionError, into: RustBuffer): void;
+            allocationSize(value: OutputSubstitutionError): number;
+            lift(value: UniffiByteArray): OutputSubstitutionError;
+            lower(value: OutputSubstitutionError): UniffiByteArray;
+        };
+        FfiConverterTypeOutputSubstitutionProtocolError: FfiConverterObject<OutputSubstitutionProtocolErrorInterface>;
         FfiConverterTypeOutputsUnknown: FfiConverterObject<OutputsUnknownInterface>;
         FfiConverterTypeOutputsUnknownTransition: FfiConverterObject<OutputsUnknownTransitionInterface>;
         FfiConverterTypePayjoinProposal: FfiConverterObject<PayjoinProposalInterface>;
@@ -3966,6 +6618,41 @@ declare const _default: Readonly<{
         FfiConverterTypePjParseError: FfiConverterObject<PjParseErrorInterface>;
         FfiConverterTypePjParseError__as_error: FfiConverterObjectAsError<PjParseErrorInterface>;
         FfiConverterTypePjUri: FfiConverterObject<PjUriInterface>;
+        FfiConverterTypePlainOutPoint: {
+            read(from: RustBuffer): PlainOutPoint;
+            write(value: PlainOutPoint, into: RustBuffer): void;
+            allocationSize(value: PlainOutPoint): number;
+            lift(value: UniffiByteArray): PlainOutPoint;
+            lower(value: PlainOutPoint): UniffiByteArray;
+        };
+        FfiConverterTypePlainPsbtInput: {
+            read(from: RustBuffer): PlainPsbtInput;
+            write(value: PlainPsbtInput, into: RustBuffer): void;
+            allocationSize(value: PlainPsbtInput): number;
+            lift(value: UniffiByteArray): PlainPsbtInput;
+            lower(value: PlainPsbtInput): UniffiByteArray;
+        };
+        FfiConverterTypePlainTxIn: {
+            read(from: RustBuffer): PlainTxIn;
+            write(value: PlainTxIn, into: RustBuffer): void;
+            allocationSize(value: PlainTxIn): number;
+            lift(value: UniffiByteArray): PlainTxIn;
+            lower(value: PlainTxIn): UniffiByteArray;
+        };
+        FfiConverterTypePlainTxOut: {
+            read(from: RustBuffer): PlainTxOut;
+            write(value: PlainTxOut, into: RustBuffer): void;
+            allocationSize(value: PlainTxOut): number;
+            lift(value: UniffiByteArray): PlainTxOut;
+            lower(value: PlainTxOut): UniffiByteArray;
+        };
+        FfiConverterTypePlainWeight: {
+            read(from: RustBuffer): PlainWeight;
+            write(value: PlainWeight, into: RustBuffer): void;
+            allocationSize(value: PlainWeight): number;
+            lift(value: UniffiByteArray): PlainWeight;
+            lower(value: PlainWeight): UniffiByteArray;
+        };
         FfiConverterTypePollingForProposal: FfiConverterObject<PollingForProposalInterface>;
         FfiConverterTypePollingForProposalTransition: FfiConverterObject<PollingForProposalTransitionInterface>;
         FfiConverterTypePollingForProposalTransitionOutcome: {
@@ -3979,15 +6666,74 @@ declare const _default: Readonly<{
         FfiConverterTypeProtocolError: FfiConverterObject<ProtocolErrorInterface>;
         FfiConverterTypeProvisionalProposal: FfiConverterObject<ProvisionalProposalInterface>;
         FfiConverterTypeProvisionalProposalTransition: FfiConverterObject<ProvisionalProposalTransitionInterface>;
-        FfiConverterTypePsbtInput: {
-            read(from: RustBuffer): PsbtInput;
-            write(value: PsbtInput, into: RustBuffer): void;
-            allocationSize(value: PsbtInput): number;
-            lift(value: UniffiByteArray): PsbtInput;
-            lower(value: PsbtInput): UniffiByteArray;
-        };
         FfiConverterTypePsbtInputError: FfiConverterObject<PsbtInputErrorInterface>;
-        FfiConverterTypePsbtInputError__as_error: FfiConverterObjectAsError<PsbtInputErrorInterface>;
+        FfiConverterTypePsbtParseError: {
+            read(from: RustBuffer): {
+                readonly tag: PsbtParseError_Tags.InvalidPsbt;
+                readonly inner: Readonly<[string]>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "PsbtParseError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            write(value: {
+                readonly tag: PsbtParseError_Tags.InvalidPsbt;
+                readonly inner: Readonly<[string]>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "PsbtParseError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            }, into: RustBuffer): void;
+            allocationSize(value: {
+                readonly tag: PsbtParseError_Tags.InvalidPsbt;
+                readonly inner: Readonly<[string]>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "PsbtParseError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            }): number;
+            lift(value: UniffiByteArray): {
+                readonly tag: PsbtParseError_Tags.InvalidPsbt;
+                readonly inner: Readonly<[string]>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "PsbtParseError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            lower(value: {
+                readonly tag: PsbtParseError_Tags.InvalidPsbt;
+                readonly inner: Readonly<[string]>;
+                /**
+                 * @private
+                 * This field is private and should not be used, use `tag` instead.
+                 */
+                readonly [uniffiTypeNameSymbol]: "PsbtParseError";
+                name: string;
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            }): UniffiByteArray;
+        };
         FfiConverterTypeReceiveSession: {
             read(from: RustBuffer): ReceiveSession;
             write(value: ReceiveSession, into: RustBuffer): void;
@@ -3996,6 +6742,13 @@ declare const _default: Readonly<{
             lower(value: ReceiveSession): UniffiByteArray;
         };
         FfiConverterTypeReceiverBuilder: FfiConverterObject<ReceiverBuilderInterface>;
+        FfiConverterTypeReceiverBuilderError: {
+            read(from: RustBuffer): ReceiverBuilderError;
+            write(value: ReceiverBuilderError, into: RustBuffer): void;
+            allocationSize(value: ReceiverBuilderError): number;
+            lift(value: UniffiByteArray): ReceiverBuilderError;
+            lower(value: ReceiverBuilderError): UniffiByteArray;
+        };
         FfiConverterTypeReceiverError: {
             read(from: RustBuffer): ReceiverError;
             write(value: ReceiverError, into: RustBuffer): void;
@@ -4062,6 +6815,14 @@ declare const _default: Readonly<{
             lower(value: SendSession): UniffiByteArray;
         };
         FfiConverterTypeSenderBuilder: FfiConverterObject<SenderBuilderInterface>;
+        FfiConverterTypeSenderCancelTransition: FfiConverterObject<SenderCancelTransitionInterface>;
+        FfiConverterTypeSenderInputError: {
+            read(from: RustBuffer): SenderInputError;
+            write(value: SenderInputError, into: RustBuffer): void;
+            allocationSize(value: SenderInputError): number;
+            lift(value: UniffiByteArray): SenderInputError;
+            lower(value: SenderInputError): UniffiByteArray;
+        };
         FfiConverterTypeSenderPersistedError: {
             read(from: RustBuffer): SenderPersistedError;
             write(value: SenderPersistedError, into: RustBuffer): void;
@@ -4095,17 +6856,10 @@ declare const _default: Readonly<{
         FfiConverterTypeWantsInputsTransition: FfiConverterObject<WantsInputsTransitionInterface>;
         FfiConverterTypeWantsOutputs: FfiConverterObject<WantsOutputsInterface>;
         FfiConverterTypeWantsOutputsTransition: FfiConverterObject<WantsOutputsTransitionInterface>;
-        FfiConverterTypeWeight: {
-            read(from: RustBuffer): Weight;
-            write(value: Weight, into: RustBuffer): void;
-            allocationSize(value: Weight): number;
-            lift(value: UniffiByteArray): Weight;
-            lower(value: Weight): UniffiByteArray;
-        };
         FfiConverterTypeWellKnownError: FfiConverterObject<WellKnownErrorInterface>;
         FfiConverterTypeWithReplyKey: FfiConverterObject<WithReplyKeyInterface>;
         FfiConverterTypeWithReplyKeyTransition: FfiConverterObject<WithReplyKeyTransitionInterface>;
     };
 }>;
 export default _default;
-//# sourceMappingURL=payjoin_ffi.d.ts.map
+//# sourceMappingURL=payjoin.d.ts.map